पाइथन स्लाइस सूची में पहला और अंतिम तत्व स्लाइस

Question

क्या सूची में केवल प्रथम और अंतिम आइटम को टुकड़ा करने का कोई तरीका है?

उदाहरण के लिए; यदि यह मेरी सूची है:

>>> some_list 
['1', 'B', '3', 'D', '5', 'F'] 

मैं ऐसा करना चाहते हैं (जाहिर है [0,-1] मान्य सिंटैक्स नहीं है):

>>> first_item, last_item = some_list[0,-1] 
>>> print first_item 
'1' 
>>> print last_item 
'F' 

कुछ बातें मैं कोशिश की है:

In [3]: some_list[::-1] 
Out[3]: ['F', '5', 'D', '3', 'B', '1'] 

In [4]: some_list[-1:1:-1] 
Out[4]: ['F', '5', 'D', '3'] 

In [5]: some_list[0:-1:-1] 
Out[5]: [] 
... 

Answer 1

एक ही रास्ता:

some_list[::len(some_list)-1] 

एक बेहतर तरीका (टुकड़ा करने की क्रिया का उपयोग नहीं करता है, लेकिन है पढ़ने में आसान):

[some_list[0], some_list[-1]] 

Answer 2

आप ऐसा कर सकते हैं:

some_list[0::len(some_list)-1] 

Answer 3

वास्तव में, मैं बस यह समझ से बाहर:

In [20]: some_list[::len(some_list) - 1] 
Out[20]: ['1', 'F'] 

Answer 4

इसके बारे में क्या?

>>> first_element, last_element = some_list[0], some_list[-1] 

Answer 5

first, last = some_list[0], some_list[-1] 

Answer 6

बस सोचा था कि मैं कैसे numpy के फैंसी अनुक्रमण के साथ ऐसा करना दिखाने चाहते हैं:

>>> import numpy 
>>> some_list = ['1', 'B', '3', 'D', '5', 'F'] 
>>> numpy.array(some_list)[[0,-1]] 
array(['1', 'F'], 
     dtype='|S1') 

ध्यान दें कि यह भी मनमाने ढंग से सूचकांक स्थानों, जो [::len(some_list)-1] विधि के लिए काम नहीं करेंगे समर्थन करता है:

>>> numpy.array(some_list)[[0,2,-1]] 
array(['1', '3', 'F'], 
     dtype='|S1') 

डीएसएम बताते हैं के रूप में, आप itemgetter के साथ इसी तरह कुछ कर सकते हैं:

>>> import operator 
>>> operator.itemgetter(0, 2, -1)(some_list) 
('1', '3', 'F') 

Answer 7

कुछ लोग गलत सवाल का जवाब दे रहे हैं, ऐसा लगता है। आपने कहा था कि आप क्या करना चाहते:।

>>> first_item, last_item = some_list[0,-1] 
>>> print first_item 
'1' 
>>> print last_item 
'F' 

Ie, आप पहली और आखिरी अलग चर में प्रत्येक तत्व को निकालने के लिए चाहते हैं।

इस मामले में, द्वारा मैथ्यू एडम्स, pemistahl, और katrielalex जवाब मान्य हैं। यह सिर्फ एक यौगिक काम है:

first_item, last_item = some_list[0], some_list[-1] 

लेकिन बाद में आप एक उलझन राज्य: "मैं एक ही पंक्ति में विभाजित कर रहा हूँ, और कहा कि समय के लिए होता है यह बंटवारे खर्च करने के लिए दो बार:"

x, y = a.split("-")[0], a.split("-")[-1] 

इसलिए दो स्प्लिट() कॉल से बचने के लिए, आपको केवल उस सूची पर काम करना होगा जो एक बार विभाजन से होता है।

इस मामले में, एक पंक्ति में बहुत ज्यादा करने की कोशिश कर स्पष्टता और सादगी के लिए एक हानि है।एक चर का प्रयोग करें विभाजन परिणाम धारण करने के लिए: ", कैसे एक नई सूची प्राप्त करने के लिए एक सूची के पहले और अंतिम तत्वों से मिलकर"

lst = a.split("-") 
first_item, last_item = lst[0], lst[-1] 

अन्य प्रतिक्रियाओं के सवाल का जवाब दे वे शायद आपके शीर्षक से प्रेरित थे, जो आपके प्रश्न की सावधानीपूर्वक पढ़ने के अनुसार स्लाइसिंग का उल्लेख करते हैं, जिसे आप वास्तव में नहीं चाहते हैं।

AFAIK 0 और एक सूची के अंतिम तत्वों के साथ एक नई सूची प्राप्त करने के लिए 3 तरीके हैं:

>>> s = 'Python ver. 3.4' 
>>> a = s.split() 
>>> a 
['Python', 'ver.', '3.4'] 

>>> [ a[0], a[-1] ]  # mentioned above 
['Python', '3.4'] 

>>> a[::len(a)-1]   # also mentioned above 
['Python', '3.4'] 

>>> [ a[e] for e in (0,-1) ] # list comprehension, nobody mentioned? 
['Python', '3.4'] 

# Or, if you insist on doing it in one line: 
>>> [ s.split()[e] for e in (0,-1) ] 
['Python', '3.4'] 

सूची समझ दृष्टिकोण का लाभ यह है कि टपल में सूचकांक के सेट मनमाने ढंग से किया जा सकता है और प्रोग्रामेटिक रूप से जेनरेट किया गया।

Answer 8

आप की तरह `

y[::max(1, len(y)-1)] 

कुछ का उपयोग क्या तुम सच में टुकड़ा करने की क्रिया उपयोग करना चाहते हैं कर सकते हैं। इसका लाभ यह है कि यह इंडेक्स त्रुटियों को नहीं दे सकता है और लंबाई 1 या 0 सूचियों के साथ भी काम करता है।

Answer 9

यह "टुकड़ा" नहीं है, लेकिन यह एक सामान्य समाधान है जो स्पष्ट अनुक्रमण का उपयोग नहीं करता है, और परिदृश्य के लिए काम करता है जहां प्रश्न में अनुक्रम अज्ञात है (इसलिए आप बना सकते हैं और "टुकड़ा" एक ही पंक्ति में दो बार बनाने और अनुक्रमण के बिना दो बार): operator.itemgetter

import operator 

# Done once and reused 
first_and_last = operator.itemgetter(0, -1) 

... 

first, last = first_and_last(some_list) 

तुम बस के रूप में (उपयोग के समय संक्षिप्तता के लिए from operator import itemgetter के बाद) इनलाइन सकता है:

first, last = itemgetter(0, -1)(some_list) 

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

इस प्रकार, अपने विशिष्ट उपयोग के लिए, आप बदल सकते हैं:

साथ

x, y = a.split("-")[0], a.split("-")[-1] 

:

x, y = itemgetter(0, -1)(a.split("-")) 

और split केवल एक बार len जाँच या डबल के लिए एक लगातार नाम पर पूरा list भंडारण के बिना -इंडेक्सिंग या पसंद है।

ध्यान दें कि एक से अधिक आइटम के लिए itemgetter रिटर्न एक tuple, नहीं एक list, इसलिए यदि आप अभी कर रहे हैं यह विशिष्ट नाम को खोल नहीं, और एक सच्चे list की जरूरत है, आप list निर्माता में कॉल रैप करने के लिए होगा।

Answer 10

अजगर 3 केवल जवाब देने के (कि टुकड़ा करने की क्रिया का उपयोग नहीं करता है या list के बाकी फेंक, लेकिन वैसे भी काफी अच्छा हो सकता है) उपयोग सामान्यीकरण खोल पाने के लिए है first और last बीच में से अलग:

first, *_, last = some_list 

तर्कों के "आराम" के लिए पकड़ने के रूप में _ की पसंद मनमाने ढंग से है; उन्हें _ नाम से संग्रहीत किया जाएगा जिसे अक्सर "जिन चीजों की परवाह नहीं है" के लिए स्टैंड-इन के रूप में उपयोग किया जाता है।

कई अन्य समाधानों के विपरीत, यह सुनिश्चित करेगा कि अनुक्रम में कम से कम दो तत्व हैं; अगर केवल एक है (इसलिए first और last समान होगा), यह एक अपवाद उठाएगा (ValueError)।

Answer 11

अधिक सामान्य मामला: सूची के प्रत्येक छोर से वापसी एन अंक

जवाब विशिष्ट पहली और आखिरी, लेकिन कुछ, अपने आप की तरह, की तलाश में किया जा सकता है एक समाधान के लिए है कि एक के लिए लागू किया जा सकता के लिए काम अधिक सामान्य मामला है जिसमें आप सूची के दोनों ओर से शीर्ष N अंक लौट सकते हैं (कहते हैं कि तुम एक क्रमबद्ध सूची है और केवल 5 उच्चतम या न्यूनतम चाहते हैं), मैं निम्नलिखित समाधान के साथ आया था:

In [1] 
def GetWings(inlist,winglen): 
    if len(inlist)<=winglen*2: 
     outlist=inlist 
    else: 
     outlist=list(inlist[:winglen]) 
     outlist.extend(list(inlist[-winglen:])) 
    return outlist 

और सूची से नीचे और शीर्ष 3 संख्याओं को वापस करने के लिए एक उदाहरण 1-10:

In [2] 
GetWings([1,2,3,4,5,6,7,8,9,10],3) 

#Out[2] 
#[1, 2, 3, 8, 9, 10] 

Answer 12

def recall(x): 
    num1 = x[-4:] 
    num2 = x[::-1] 
    num3 = num2[-4:] 
    num4 = [num3, num1] 
    return num4 

अब बस समारोह के बाहर एक चर बनाने के लिए और समारोह याद: इस तरह:

avg = recall("idreesjaneqand") 
print(avg)