python - अंत से सूची बनाते समय पायथन इंडेक्स-1(0 के विपरीत) क्यों शुरू होता है?




list (5)

इस सवाल का पहले से ही यहाँ एक जवाब है:

list = ["a", "b", "c", "d"]
print(list[3]) # Number 3 is "d"

print(list[-4]) # Number -4 is "a"

आप सहजता से इसे इस तरह समझ सकते थे

steps= ["a", "b", "c", "d"]

मान लीजिए कि आप d से शुरू करते हैं, एक आपका घूरने वाला बिंदु है जहां आप खड़े हैं (या अपना घर), इसलिए इसे 0 के रूप में चिह्नित करें (क्योंकि आप अभी तक नहीं चले थे)

एक कदम को b, दूसरे चरण को c और तीसरे d पर पहुंचने के लिए ले जाएं।

फिर कैसे के बारे में आप डी से लौटते हैं (या अपने कार्यालय से अपने घर पर लौटते हैं)। आपका घर 0 क्योंकि आपका परिवार वहां रहता है, इसलिए आपका कार्यालय 0 नहीं हो सकता है। यह आपका अंतिम पड़ाव है।

इसलिए जब आप घर वापस लौटते हैं। d अंतिम पहला पड़ाव है जहां आप घर के लिए शुरू करते हैं, c अंतिम दूसरा है ...।


इसे दूसरे तरीके से समझाने के लिए, क्योंकि -0 0 बराबर है, यदि पिछड़ा 0 से शुरू होता है, तो यह दुभाषिया के लिए अस्पष्ट है।

यदि आप इसके बारे में उलझन में हैं - और पीछे की ओर अधिक स्पष्ट रूप से अनुक्रमण करने के लिए एक और तरीका खोज रहे हैं, तो आप कोशिश कर सकते हैं ~ , यह आगे का दर्पण है:

arr = ["a", "b", "c", "d"]
print(arr[~0])   # d
print(arr[~1])   # c

~ लिए विशिष्ट उपयोग "स्वैप दर्पण नोड" या "एक प्रकार की सूची में माध्यिका खोजें" जैसे हैं:

"""swap mirror node"""
def reverse(arr: List[int]) -> None:
    for i in range(len(arr) // 2):
        arr[i], arr[~i] = arr[~i], arr[i]

"""find median in a sort list"""
def median(arr: List[float]) -> float:
    mid = len(arr) // 2
    return (arr[mid] + arr[~mid]) / 2

"""deal with mirror pairs"""
# verify the number is strobogrammatic, strobogrammatic number looks the same when rotated 180 degrees
def is_strobogrammatic(num: str) -> bool:
    return all(num[i] + num[~i] in '696 00 11 88' for i in range(len(num) // 2 + 1))

~ वास्तव में उलटा कोड और पूरक कोड की एक गणित चाल है, और कुछ स्थितियों में समझना अधिक आसान है।

अजगर की चाल का उपयोग करना चाहिए, इस बारे में चर्चा ~

मेरी राय में, यदि यह अपने आप में बनाए रखा गया कोड है, तो आप संभावित बग से बचने के लिए किसी भी चाल का उपयोग कर सकते हैं या संभवत: उच्च पठनीयता और प्रयोज्यता के कारण लक्ष्य को आसान बना सकते हैं। लेकिन टीम वर्क में, 'बहुत चालाक' कोड का उपयोग करने से बचें , आपके सहकर्मियों के लिए परेशानी ला सकते हैं।

उदाहरण के लिए, इस समस्या को हल करने के लिए स्टीफन पोचमन का एक संक्षिप्त कोड है । मैंने उनके कोड से बहुत कुछ सीखा है। लेकिन कुछ सिर्फ मनोरंजन के लिए हैं, बहुत उपयोग करने लायक है।

# a strobogrammatic number is a number that looks the same when rotated 180 degrees (looked at upside down)
# find all strobogrammatic numbers that are of length = n
def findStrobogrammatic(self, n):
    nums = n % 2 * list('018') or ['']
    while n > 1:
        n -= 2
        # n < 2 is so genius here
        nums = [a + num + b for a, b in '00 11 88 69 96'.split()[n < 2:] for num in nums]
    return nums

यदि आप रुचि रखते हैं, तो मैंने इस तरह से अजगर की चाल को संक्षेप में प्रस्तुत किया है।


क्योंकि -0 पायथन में 0
0 साथ आपको सूची का पहला तत्व मिलता है और
-1 साथ आपको सूची का अंतिम तत्व मिलता है

list = ["a", "b", "c", "d"]
print(list[0]) # "a"
print(list[-1]) # d

आप इसे list[len(list) - x] लिए आशुलिपि के रूप में भी सोच सकते हैं list[len(list) - x] जहां x पीछे से तत्व स्थिति है। यह केवल तभी मान्य है जब 0 < -(-x) < len(list)

print(list[-1]) # d
print(list[len(list) - 1]) # d
print(list[-5]) # list index out of range
print(list[len(list) - 5]) # a

मॉड्यूलर मुहावरों का उपयोग करके इस मुहावरे को उचित ठहराया जा सकता है। हम आगे चलकर तत्वों की सूची द्वारा प्राप्त सूचियों में एक सेल के संदर्भ में सूचकांक के बारे में सोच सकते हैं -1 सूची के अंतिम तत्व का जिक्र इस का एक स्वाभाविक सामान्यीकरण है, क्योंकि हम सूची में अंतिम तत्व पर पहुंचते हैं यदि हम सूची की शुरुआत से एक कदम पीछे चलते हैं।

किसी भी सूची xs और अनुक्रमणिका के लिए i सकारात्मक या नकारात्मक , अभिव्यक्ति

xs[i]

या तो नीचे दिए गए अभिव्यक्ति के समान मूल्य होगा या IndexError उत्पादन करेगा:

xs[i % len(xs)]

अंतिम तत्व का सूचकांक -1 + len(xs) जो -1 mod len(xs) अनुरूप है। उदाहरण के लिए, लंबाई 12 की एक सरणी में, अंतिम तत्व का विहित सूचकांक 11. 11 है -1 से 12 के अनुरूप है।

पाइथन में, हालांकि, सरणियों को अधिक बार वृत्ताकार की तुलना में रैखिक डेटा संरचनाओं के रूप में उपयोग किया जाता है, इसलिए -1 + len(xs) या उससे छोटे-बड़े -1 + len(xs) से बड़े सूचकांक सीमा से बाहर हैं क्योंकि उनके लिए और शायद ही कभी आवश्यकता होती है यदि काउंटर का आकार कभी बदल जाता है तो प्रभाव वास्तव में प्रतिवाद होगा।


list[-1]

के लिए छोटा हाथ है:

list[len(list)-1]

len(list) भाग निहित है। इसलिए -1 अंतिम तत्व है। यह किसी भी नकारात्मक सूचकांक के लिए जाता है - len(list) से घटाव हमेशा निहित होता है





list