ਪਾਈਥਨ ਸੂਚੀ ਵਿੱਚ ਇੱਕ ਆਈਟਮ ਦਾ ਸੂਚਕਾਂਕ ਲੱਭਣਾ

ਪਾਈਥਨ ਵਿੱਚ ਸੂਚੀ ਇੰਡੈਕਸਿੰਗ ਨੂੰ ਸਮਝਣਾ

ਪਾਈਥਨ ਵਿੱਚ, ਸੂਚੀਆਂ ਇੱਕ ਬਹੁਮੁਖੀ ਅਤੇ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਵਰਤਿਆ ਜਾਣ ਵਾਲਾ ਡਾਟਾ ਢਾਂਚਾ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਆਈਟਮਾਂ ਦੇ ਆਰਡਰ ਕੀਤੇ ਸੰਗ੍ਰਹਿ ਨੂੰ ਸਟੋਰ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਇੱਕ ਸੂਚੀ ਵਿੱਚ ਇੱਕ ਖਾਸ ਆਈਟਮ ਦੇ ਸੂਚਕਾਂਕ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ ਇਹ ਜਾਣਨਾ ਇੱਕ ਬੁਨਿਆਦੀ ਹੁਨਰ ਹੈ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਗਤੀਸ਼ੀਲ ਅਤੇ ਵੱਡੇ ਡੇਟਾਸੈਟਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ।

ਉਦਾਹਰਨ ਲਈ, ["foo", "bar", "baz"] ਵਰਗੀ ਇੱਕ ਸੂਚੀ, ਅਤੇ "bar" ਵਰਗੀ ਇੱਕ ਆਈਟਮ, ਇਹ ਜਾਣਨਾ ਜ਼ਰੂਰੀ ਹੈ ਕਿ ਇਸਦੀ ਸਥਿਤੀ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਕਿਵੇਂ ਖੋਜਿਆ ਜਾਵੇ। ਇਹ ਗਾਈਡ ਪਾਈਥਨ ਦੇ ਬਿਲਟ-ਇਨ ਤਰੀਕਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਸੂਚੀ ਦੇ ਅੰਦਰ ਇੱਕ ਆਈਟਮ ਦੇ ਸੂਚਕਾਂਕ ਨੂੰ ਲੱਭਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਕਰੇਗੀ।

ਪਾਈਥਨ ਸਕ੍ਰਿਪਟਾਂ ਦੀ ਵਿਸਤ੍ਰਿਤ ਵਿਆਖਿਆ

ਪਹਿਲੀ ਸਕ੍ਰਿਪਟ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਸੂਚੀ ਵਿੱਚ ਇੱਕ ਆਈਟਮ ਦੇ ਸੂਚਕਾਂਕ ਨੂੰ ਲੱਭਣ ਲਈ ਇੱਕ ਸਿੱਧਾ ਤਰੀਕਾ ਦਰਸਾਉਂਦੀ ਹੈ .index() ਢੰਗ. ਸੂਚੀ ਦਿੱਤੀ ਹੈ my_list ਵਰਗੇ ਤੱਤ ਸ਼ਾਮਿਲ ਹਨ ["foo", "bar", "baz"], ਦ .index() ਵਿਧੀ ਨੂੰ ਆਈਟਮ ਨਾਲ ਕਿਹਾ ਜਾਂਦਾ ਹੈ "bar" ਇਸਦੀ ਸਥਿਤੀ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ. ਜੇਕਰ ਆਈਟਮ ਸੂਚੀ ਵਿੱਚ ਮੌਜੂਦ ਹੈ, ਤਾਂ ਵਿਧੀ ਇਸਦੀ ਸੂਚਕਾਂਕ ਨੂੰ ਵਾਪਸ ਕਰਦੀ ਹੈ, ਜੋ ਫਿਰ ਛਾਪੀ ਜਾਂਦੀ ਹੈ। ਇਹ ਪਹੁੰਚ ਸਧਾਰਨ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ ਕੁਸ਼ਲ ਹੈ ਜਿੱਥੇ ਸੂਚੀ ਵਿੱਚ ਆਈਟਮ ਮੌਜੂਦ ਹੋਣ ਦੀ ਗਰੰਟੀ ਹੈ। ਹਾਲਾਂਕਿ, ਜੇਕਰ ਆਈਟਮ ਨਹੀਂ ਮਿਲਦੀ ਹੈ, ਤਾਂ ਇਹ ਏ ValueError, ਜਿਸ ਨੂੰ ਰਨਟਾਈਮ ਗਲਤੀਆਂ ਤੋਂ ਬਚਣ ਲਈ ਸੰਭਾਲਣ ਦੀ ਲੋੜ ਹੈ।

ਦੂਜੀ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਨੂੰ ਸ਼ਾਮਲ ਕਰਕੇ ਪਹਿਲੀ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈ try: ਅਤੇ except ValueError: ਬਲਾਕ. ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਜੇਕਰ ਸੂਚੀ ਵਿੱਚ ਆਈਟਮ ਨਹੀਂ ਮਿਲਦੀ ਹੈ, ਤਾਂ ਪ੍ਰੋਗਰਾਮ ਦੇ ਕਰੈਸ਼ ਹੋਣ ਦੀ ਬਜਾਏ ਇੱਕ ਕਸਟਮ ਗਲਤੀ ਸੁਨੇਹਾ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਸਕ੍ਰਿਪਟ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀ ਹੈ get_index(my_list, item) ਜੋ ਕਿ ਨਿਰਧਾਰਤ ਆਈਟਮ ਦੇ ਸੂਚਕਾਂਕ ਨੂੰ ਲੱਭਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ। ਜੇ ਆਈਟਮ ਮਿਲਦੀ ਹੈ, ਤਾਂ ਇਹ ਸੂਚਕਾਂਕ ਵਾਪਸ ਕਰਦੀ ਹੈ; ਜੇ ਨਹੀਂ, ਤਾਂ ਇਹ ਫੜਦਾ ਹੈ ValueError ਅਤੇ ਇੱਕ ਸੁਨੇਹਾ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਆਈਟਮ ਨਹੀਂ ਮਿਲੀ ਸੀ। ਇਹ ਫੰਕਸ਼ਨ ਨੂੰ ਹੋਰ ਮਜਬੂਤ ਅਤੇ ਦ੍ਰਿਸ਼ਾਂ ਲਈ ਢੁਕਵਾਂ ਬਣਾਉਂਦਾ ਹੈ ਜਿੱਥੇ ਸੂਚੀ ਵਿੱਚ ਆਈਟਮ ਦੀ ਮੌਜੂਦਗੀ ਅਨਿਸ਼ਚਿਤ ਹੈ।

ਤੀਜੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਇੱਕ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਵਰਤੋਂ ਦੇ ਕੇਸ ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਕਰਦੇ ਹੋਏ, ਕਈ ਆਈਟਮਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਹ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ get_indices(my_list, items) ਜੋ ਖੋਜ ਕਰਨ ਲਈ ਆਈਟਮਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਅਤੇ ਹੋਰ ਸੂਚੀ ਲੈਂਦਾ ਹੈ। ਇਹ ਇੱਕ ਖਾਲੀ ਸੂਚੀ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ indices ਨਤੀਜਿਆਂ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ. ਫੰਕਸ਼ਨ ਫਿਰ ਏ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਈਟਮਾਂ ਉੱਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈ for item in items: ਲੂਪ, ਮੁੱਖ ਸੂਚੀ ਵਿੱਚ ਹਰੇਕ ਆਈਟਮ ਦੇ ਸੂਚਕਾਂਕ ਨੂੰ ਲੱਭਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਹੈ। ਜੇਕਰ ਆਈਟਮ ਲੱਭੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਇਹ ਆਈਟਮ ਦਾ ਇੱਕ ਟੁਪਲ ਅਤੇ ਇਸਦੇ ਸੂਚਕਾਂਕ ਨੂੰ ਜੋੜਦਾ ਹੈ indices. ਜੇਕਰ ਨਹੀਂ, ਤਾਂ ਇਹ ਆਈਟਮ ਅਤੇ ਸਤਰ ਦਾ ਇੱਕ ਟੁਪਲ ਜੋੜਦਾ ਹੈ "not found". ਇਹ ਪਹੁੰਚ ਇੱਕ ਸਿੰਗਲ ਪਾਸ ਵਿੱਚ ਕਈ ਖੋਜ ਪ੍ਰਸ਼ਨਾਂ ਨੂੰ ਬੈਚ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ, ਕੁਸ਼ਲਤਾ ਅਤੇ ਪੜ੍ਹਨਯੋਗਤਾ ਨੂੰ ਵਧਾਉਣ ਲਈ ਉਪਯੋਗੀ ਹੈ।

ਕੁੱਲ ਮਿਲਾ ਕੇ, ਇਹ ਸਕ੍ਰਿਪਟਾਂ ਪਾਈਥਨ ਵਿੱਚ ਸੂਚੀਆਂ ਖੋਜਣ ਲਈ ਬੁਨਿਆਦੀ ਤਕਨੀਕਾਂ ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਕਰਦੀਆਂ ਹਨ, ਹਰੇਕ ਵਧਦੀ ਜਟਿਲਤਾ ਅਤੇ ਮਜ਼ਬੂਤੀ ਨਾਲ। ਦੀ ਵਰਤੋਂ .index() ਮੁੱਢਲੀ ਪ੍ਰਾਪਤੀ ਲਈ, ਨਾਲ ਮਿਲਾ ਕੇ try: ਅਤੇ except ਗਲਤੀ ਨੂੰ ਸੰਭਾਲਣ ਲਈ, ਅਤੇ ਮਲਟੀਪਲ ਆਈਟਮਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਲੂਪਸ, ਪਾਈਥਨ ਦੇ ਸੂਚੀ ਕਾਰਜਾਂ ਦੀ ਬਹੁਪੱਖੀਤਾ ਅਤੇ ਸ਼ਕਤੀ ਨੂੰ ਉਜਾਗਰ ਕਰਦਾ ਹੈ। ਇਹਨਾਂ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਵੱਖ-ਵੱਖ ਐਪਲੀਕੇਸ਼ਨ ਲੋੜਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਅਨੁਕੂਲਿਤ ਅਤੇ ਵਿਸਤਾਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਸਧਾਰਨ ਖੋਜ ਤੋਂ ਲੈ ਕੇ ਵਧੇਰੇ ਤਕਨੀਕੀ ਡਾਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਕਾਰਜਾਂ ਤੱਕ।

my_list = ["foo", "bar", "baz"]
item = "bar"
index = my_list.index(item)
print(f"The index of '{item}' is {index}")

def get_index(my_list, item):
    try:
        index = my_list.index(item)
        return index
    except ValueError:
        return f"'{item}' not found in the list"

my_list = ["foo", "bar", "baz"]
item = "bar"
print(f"The index of '{item}' is {get_index(my_list, item)}")

def get_indices(my_list, items):
    indices = []
    for item in items:
        try:
            index = my_list.index(item)
            indices.append((item, index))
        except ValueError:
            indices.append((item, "not found"))
    return indices

my_list = ["foo", "bar", "baz"]
items = ["bar", "baz", "qux"]
print(f"Indices: {get_indices(my_list, items)}")

ਪਾਈਥਨ ਸੂਚੀਆਂ ਵਿੱਚ ਸੂਚਕਾਂਕ ਲੱਭਣ ਲਈ ਉੱਨਤ ਤਕਨੀਕਾਂ

ਪਾਈਥਨ ਸੂਚੀ ਵਿੱਚ ਇੱਕ ਆਈਟਮ ਦੇ ਸੂਚਕਾਂਕ ਨੂੰ ਲੱਭਣ ਦੇ ਬੁਨਿਆਦੀ ਤਰੀਕਿਆਂ ਤੋਂ ਇਲਾਵਾ, ਇੱਥੇ ਹੋਰ ਤਕਨੀਕੀ ਤਕਨੀਕਾਂ ਹਨ ਜੋ ਕੁਝ ਖਾਸ ਸਥਿਤੀਆਂ ਵਿੱਚ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਅਜਿਹੀ ਇੱਕ ਤਕਨੀਕ ਸੂਚਕਾਂਕ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਅਤੇ ਖੋਜਣ ਲਈ ਸੂਚੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੀ ਹੈ। ਇੱਕ ਸੂਚੀ ਸਮਝ ਸੂਚੀਆਂ ਬਣਾਉਣ ਦਾ ਇੱਕ ਸੰਖੇਪ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ ਅਤੇ ਕਿਸੇ ਖਾਸ ਆਈਟਮ ਦੇ ਸਾਰੇ ਸੂਚਕਾਂਕ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ ਜੇਕਰ ਇਹ ਸੂਚੀ ਵਿੱਚ ਕਈ ਵਾਰ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਇੱਕ ਸੂਚੀ ਵਿੱਚ ਇੱਕ ਆਈਟਮ ਦੇ ਡੁਪਲੀਕੇਟ ਸ਼ਾਮਲ ਹਨ, [i for i, x in enumerate(my_list) if x == item] ਸਾਰੇ ਸੂਚਕਾਂਕ ਦੀ ਇੱਕ ਸੂਚੀ ਵਾਪਸ ਕਰੇਗਾ ਜਿੱਥੇ ਆਈਟਮ ਮਿਲਦੀ ਹੈ। ਇਹ ਵਿਧੀ ਨਾ ਸਿਰਫ਼ ਸੰਖੇਪ ਹੈ, ਸਗੋਂ ਅਜਿਹੇ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ ਬਹੁਤ ਜ਼ਿਆਦਾ ਪੜ੍ਹਨਯੋਗ ਅਤੇ ਕੁਸ਼ਲ ਹੈ।

ਇੱਕ ਹੋਰ ਉੱਨਤ ਪਹੁੰਚ ਵਿੱਚ ਦੀ ਵਰਤੋਂ ਸ਼ਾਮਲ ਹੈ numpy ਲਾਇਬ੍ਰੇਰੀ, ਜੋ ਕਿ ਖਾਸ ਤੌਰ 'ਤੇ ਵੱਡੇ ਡੇਟਾਸੇਟਾਂ ਅਤੇ ਸੰਖਿਆਤਮਕ ਕਾਰਵਾਈਆਂ ਲਈ ਉਪਯੋਗੀ ਹੈ। numpy ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ np.where() ਫੰਕਸ਼ਨ ਜੋ ਕਿ ਮੂਲ ਪਾਈਥਨ ਸੂਚੀਆਂ ਦੇ ਮੁਕਾਬਲੇ ਇੰਡੈਕਸ ਨੂੰ ਵਧੇਰੇ ਕਾਰਗੁਜ਼ਾਰੀ ਵਾਲੇ ਢੰਗ ਨਾਲ ਲੱਭਣ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਉਦਾਹਰਣ ਲਈ, np.where(np.array(my_list) == item)[0] ਸੂਚਕਾਂਕ ਦੀ ਇੱਕ ਐਰੇ ਵਾਪਸ ਕਰੇਗਾ ਜਿੱਥੇ ਆਈਟਮ ਮਿਲਦੀ ਹੈ। ਇਹ ਖਾਸ ਤੌਰ 'ਤੇ ਫਾਇਦੇਮੰਦ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਵੱਡੇ ਐਰੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹਨ ਜਾਂ ਜਦੋਂ ਪ੍ਰਦਰਸ਼ਨ ਇੱਕ ਮਹੱਤਵਪੂਰਣ ਚਿੰਤਾ ਹੁੰਦੀ ਹੈ। ਅਜਿਹੀਆਂ ਵਿਸ਼ੇਸ਼ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸੂਚਕਾਂਕ ਖੋਜ ਕਾਰਜਾਂ ਦੀ ਕੁਸ਼ਲਤਾ ਅਤੇ ਮਾਪਯੋਗਤਾ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਵਧਾ ਸਕਦਾ ਹੈ।