software - python tutorial




क्या एक पाइथन लैम्ब्डा अभिव्यक्ति में एकाधिक बयान संभव है? (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]

मैं एक पाइथन नौसिखिया निम्नलिखित प्राप्त करने की कोशिश कर रहा हूँ:

मेरे पास सूचियों की एक सूची है:

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

मैं नक्शा lst को एक और सूची में चाहता हूं जिसमें प्रत्येक उपन्यास से केवल दूसरा सबसे छोटा नंबर हो। तो परिणाम होना चाहिए:

[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

क्या पाइथन में मानचित्र के साथ ऐसा करने का कोई तरीका है लेकिन नामित फ़ंक्शन को परिभाषित किए बिना ? (उदाहरण के लिए, रूबी में अज्ञात ब्लॉक के साथ यह आसान है)


आपके विशिष्ट प्रश्न से अधिक सामान्य चिंताओं तक, यहां कई अलग-अलग उत्तर दिए जा सकते हैं। तो सबसे विशिष्ट से सबसे सामान्य से:

प्र। क्या आप लैम्ब्डा में कई कथन डाल सकते हैं?

ए। नहीं, लेकिन आपको वास्तव में लैम्ब्डा का उपयोग करने की आवश्यकता नहीं है। आप कथन को इसके बजाय एक 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]

मुझे आपको एक शानदार लेकिन भयानक हैक प्रस्तुत करने दें:

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]


मैं आपको एक और समाधान दूंगा, अपना लैम्ब्डा एक समारोह का आह्वान करें।

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

यहां से प्रारंभ () का उपयोग करना: 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]

या यदि आप लैम्ब्डा से बचना चाहते हैं और सूची के बजाय जेनरेटर चाहते हैं:

(एलएसटी में कोल के लिए क्रमबद्ध (कोला) [1]


वास्तव में एक तरीका है कि आप लैम्ब्डा में कई कथन का उपयोग कर सकते हैं। मेरा समाधान यहाँ है:

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

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

map(x, lst)

समय यात्री यहाँ। यदि आप आमतौर पर लैम्ब्डा के भीतर कई बयान चाहते हैं, तो आप उस लैम्ब्डा के तर्क के रूप में अन्य लैम्ब्डा को पास कर सकते हैं।

(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)]

हाँ। आप इसे इस तरह परिभाषित कर सकते हैं और फिर निम्नलिखित के साथ अपने एकाधिक अभिव्यक्तियों को लपेट सकते हैं:

योजना शुरू होती है:

शुरू = लैम्ब्डा * एक्स: एक्स [-1]

सामान्य लिस्प प्रजन:

progn = lambda * x: x [-1]






python