विषम पदों पर सूची के तत्वों को निकालें

Question

इसलिए मैं एक सूची बनाना चाहता हूं जो कुछ मौजूदा सूची की एक सूची है।

उदाहरण के लिए,

L = [1, 2, 3, 4, 5, 6, 7], मैं एक sublist बनाना चाहते हैं liऐसा है कि liसभी में तत्व शामिल हैं Lअजीब पदों पर।

जबकि मैं इसे कर सकता हूं

L = [1, 2, 3, 4, 5, 6, 7]
li = []
count = 0
for i in L:
    if count % 2 == 1:
        li.append(i)
    count += 1

लेकिन मैं जानना चाहता हूं कि क्या कुशलता से और कम संख्या में एक ही तरीका है।

Comments

@AleedKhan: उन्हें एक प्रश्न में समझ की आवश्यकता क्यों है?

— तमारा विज्समैन

@TomWijsman: सूची की समझ । ETA: अवहेलना है कि: मैं चारों ओर शिकार किया और तुम्हारा यह जवाब है कि आप मजाक कर रहे हैं इंगित करता है की खोज की । अगली बार स्माइली चेहरा लगाएं!

— डेविड रॉबिन्सन

@DavidRobinson: लेकिन अन्य लोग यह बता सकते हैं कि, ओपी के लिए यह स्पष्ट नहीं हो सकता है कि दो अस्पष्ट शब्दों के साथ उसका क्या अर्थ है। बस यहाँ और वहाँ कुछ टिप्पणियों के साथ छुरा घोंपते हैं, इसलिए लोग बेहतर सामग्री लिखते हैं; और ओपी या आगंतुकों के

— अनाचार

Answer 1

उपाय

हाँ तुम कर सकते हो:

l = L[1::2]

और यह सब है। परिणाम में निम्नलिखित पदों पर रखे गए तत्व शामिल होंगे ( 0-बेड, इसलिए पहला तत्व स्थिति में है 0, दूसरा 1आदि):

1, 3, 5

इसलिए परिणाम (वास्तविक संख्या) होगा:

2, 4, 6

व्याख्या

[1::2]अंत में बस सूची टुकड़ा करने की क्रिया के लिए एक अंकन है। आमतौर पर यह निम्नलिखित रूप में होता है:

some_list[start:stop:step]

यदि हम छोड़ दिया है start, तो डिफ़ॉल्ट ( 0) का उपयोग किया जाएगा। तो पहला तत्व (स्थिति में 0, क्योंकि अनुक्रमणिका- 0आधारित हैं) का चयन किया जाएगा। इस मामले में दूसरा तत्व चुना जाएगा।

क्योंकि दूसरा तत्व छोड़ा गया है, डिफ़ॉल्ट का उपयोग किया जा रहा है (सूची का अंत)। इसलिए सूची को दूसरे तत्व से अंत तक पुनरावृत्त किया जा रहा है ।

हमने तीसरा तर्क ( step) भी दिया है 2। जिसका मतलब है कि एक तत्व का चयन किया जाएगा, अगले को छोड़ दिया जाएगा, और इसी तरह ...

तो, इस मामले में योग करने का [1::2]मतलब है:

1. दूसरा तत्व लें (जो, वैसे, एक विषम तत्व है, यदि आप सूचकांक से न्याय करते हैं),
2. एक तत्व को छोड़ें (क्योंकि हमारे पास है step=2, इसलिए हम एक को छोड़ रहे हैं, step=1जिसके विपरीत डिफ़ॉल्ट है),
3. अगला तत्व लें,
4. दोहराएँ चरण 2. -3। जब तक सूची का अंत नहीं हो जाता,

EDIT : @PreetKukreti ने पायथन की सूची को काटते हुए अंकन पर एक और स्पष्टीकरण के लिए एक लिंक दिया। यहाँ देखें: पायथन के स्लाइस अंकन की व्याख्या करें

एक्स्ट्रा - के साथ काउंटर की जगह enumerate()

अपने कोड में, आप स्पष्ट रूप से काउंटर बनाएं और बढ़ाएं। पायथन में यह आवश्यक नहीं है, क्योंकि आप इसका उपयोग करके कुछ पुनरावृत्ति कर सकते हैं enumerate():

for count, i in enumerate(L):
    if count % 2 == 1:
        l.append(i)

उपरोक्त ठीक उसी उद्देश्य से कार्य करता है जैसा आप उपयोग कर रहे हैं।

count = 0
for i in L:
    if count % 2 == 1:
        l.append(i)
    count += 1

forपायथन में काउंटर के साथ छोरों का अनुकरण करने पर अधिक : 'छोरों' के लिए पायथन में सूचकांक तक पहुंचना

Comments

@ टोमविज्समैन इस सवाल को समझने के लिए अजगर के स्लाइसिंग सिंटैक्स को देखें

— प्रीत कुकरेती

सवाल विषम पदों के लिए पूछता है। यह भी स्थिति देता है (0,2,4,6); ऐसा लगता है कि ओपी इंडेक्स चाहता है (1,3,5), जो इसके द्वारा दिया जाएगा [1,2,3,4,5,6,7][1::2]।

— Marcin

@ मारकिन: हाँ, मैं वास्तव में एक ही निष्कर्ष (सुधार देखें) के साथ आया था। ओपी के कोड को ध्यान से पढ़ने के बाद यह बात सामने आई। मुद्दा अनुक्रमण के लिए अलग-अलग आधार पर हुआ (मेरे लिए " विषम " तत्व का अर्थ था पहला तत्व, ओपी के लिए ऐसा प्रतीत होता है कि यह दूसरा था , इसलिए इसे अनुक्रमित किया गया 1)।

— टाडेक

@TomWijsman: मुझे खेद है, मैंने यह नहीं देखा कि आपने क्या बदला है। दरअसल, एक कड़ी है, लेकिन यह न्यूमरे प्रोजेक्ट की ओर जाता है, न कि पायथन के listस्लाइसिंग के लिए। यह थोड़ा भिन्न होता है, विशेष रूप से क्योंकि list'एस स्लाइस मूल सूची का संदर्भ नहीं रखता है (न्यूमैरे में आपको .copy()मूल सरणी का संदर्भ नहीं देने के लिए स्पष्ट रूप से कॉल करने की आवश्यकता है)। लेकिन कुछ ऐसा होना अच्छा है जो कुछ पाठकों के लिए बेहतर हो। क्या आप टिप्पणी में इस लिंक को प्रस्तुत करना चाहेंगे, इसलिए मैं इसे बढ़ा सकता हूं और यह उत्तर के ठीक नीचे दिखाई देगा?

— टेडेक

@ टेडेक "विषम संख्या वाले सूचकांक" बहुत स्वाभाविक रूप से सूचक हैं जो विषम संख्याएं हैं।

— मार्सिन

Answer 2

के लिए अजीब पदों, तो आप शायद चाहते हैं:

>>>> list_ = list(range(10))
>>>> print list_[1::2]
[1, 3, 5, 7, 9]
>>>>

Answer 3

मुझे उनके गणित (सेट) सिंटैक्स के कारण सूची की समझ पसंद है। तो इस बारे में कैसे:

L = [1, 2, 3, 4, 5, 6, 7]
odd_numbers = [y for x,y in enumerate(L) if x%2 != 0]
even_numbers = [y for x,y in enumerate(L) if x%2 == 0]

मूल रूप से, यदि आप किसी सूची में गणना करते हैं, तो आपको सूचकांक xऔर मूल्य मिलेगा y। मैं यहाँ क्या कर रहा हूँ y, आउटपुट लिस्ट (सम या विषम) में वैल्यू डाल रहा है और इंडेक्स का उपयोग करके यह xपता लगाने के लिए कि क्या बिंदु विषम है ( x%2 != 0)।

Comments

क्या यह एन्यूमरेट (आइटम) के बजाय एन्यूमरेट (एल) नहीं होना चाहिए?

— ab123

Answer 4

आप बिटवाइज़ और ऑपरेटर का उपयोग कर सकते हैं &। आइये नीचे देखते हैं:

x = [1, 2, 3, 4, 5, 6, 7]
y = [i for i in x if i&1]
>>> 
[1, 3, 5, 7]

बिटवाइज और ऑपरेटर का उपयोग 1 के साथ किया जाता है, और इसका कारण यह काम करता है क्योंकि, द्विआधारी में लिखे जाने पर विषम संख्या में इसका पहला अंक होना चाहिए। 1. आइए देखें

23 = 1 * (2**4) + 0 * (2**3) + 1 * (2**2) + 1 * (2**1) + 1 * (2**0) = 10111
14 = 1 * (2**3) + 1 * (2**2) + 1 * (2**1) + 0 * (2**0) = 1110

और 1 के साथ ऑपरेशन केवल 1 लौटाएगा (बाइनरी में 1 में अंतिम अंक 1 भी होगा), यदि मान विषम है।

अधिक के लिए पायथन बिटवाइज़ ऑपरेटर पृष्ठ की जाँच करें ।

PS: यदि आप डेटाफ़्रेम में विषम और यहां तक ​​कि कॉलम का चयन करना चाहते हैं, तो आप इस पद्धति का उपयोग कर सकते हैं। मान लीजिए कि चेहरे के की-पॉइंट्स के x और y निर्देशांक कॉलम X1, y1, x2, आदि के रूप में दिए गए हैं ... प्रत्येक चित्र की चौड़ाई और ऊँचाई मानों के साथ x और y निर्देशांक को सामान्य करने के लिए आप बस प्रदर्शन कर सकते हैं

for i in range(df.shape[1]):
    if i&1:
        df.iloc[:, i] /= heights
    else:
        df.iloc[:, i] /= widths

यह वास्तव में सवाल से संबंधित नहीं है, लेकिन डेटा वैज्ञानिकों और कंप्यूटर विज़न इंजीनियरों के लिए यह विधि उपयोगी हो सकती है।

चीयर्स!

Answer 5

list_ = सूची (श्रेणी (9)) प्रिंट (list_ [1 :: 2])

Comments

कृपया संक्षिप्त विवरण के साथ उत्तर दें और कुछ कोड ब्लॉक को ठीक से स्वरूपित करें। धन्यवाद

— वेंकट कृष्णन