ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਵਿੱਚ, ਸੂਚੀਆਂ ਸ਼ਾਇਦ ਏਰੇ ਦੇ ਰੂਪ ਵਿੱਚ ਇੱਕ ਡੇਟਾ ਬਣਤਰ ਵਜੋਂ ਉਪਯੋਗੀ ਹੁੰਦੀਆਂ ਹਨ। ਸੂਚੀਆਂ ਕੀ ਹਨ, ਉਹਨਾਂ ਨੂੰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ? ਪਾਈਥਨ ਵਿੱਚ ਸੂਚੀਆਂ ਨਾਲ ਕਿਵੇਂ ਕੰਮ ਕਰਨਾ ਹੈ? ਤੁਸੀਂ ਸਾਡੇ ਲੇਖ ਤੋਂ ਇਸ ਬਾਰੇ ਸਿੱਖੋਗੇ.
ਪਾਈਥਨ ਵਿੱਚ ਸੂਚੀਆਂ ਕੀ ਹਨ?
ਸੂਚੀਆਂ ਨੂੰ ਅੰਸ਼ਕ ਤੌਰ 'ਤੇ ਐਰੇ ਨਾਲ ਪਛਾਣਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ ਸੂਚੀਆਂ ਦਾ ਅੰਤਰ ਅਤੇ ਫਾਇਦਾ (ਨਹੀਂ ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ) ਇਹ ਹੈ ਕਿ ਉਹ ਵੱਖ-ਵੱਖ ਡਾਟਾ ਕਿਸਮਾਂ ਨੂੰ ਜੋੜ ਸਕਦੇ ਹਨ। ਯਾਨੀ, ਸੂਚੀਕਰਨ ਆਬਜੈਕਟ ਦੇ ਕਿਸੇ ਵੀ ਕ੍ਰਮ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਹੋਰ ਸੰਭਾਵਨਾਵਾਂ ਨੂੰ ਖੋਲ੍ਹਦਾ ਹੈ। ਇੱਕ ਵੇਰੀਏਬਲ, ਜਿਸਨੂੰ ਇੱਕ ਸੂਚੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਵਿੱਚ ਮੈਮੋਰੀ ਵਿੱਚ ਇੱਕ ਢਾਂਚੇ ਦਾ ਹਵਾਲਾ ਹੁੰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਵਿਕਲਪਕ ਢਾਂਚੇ ਦੇ ਹਵਾਲੇ ਹੁੰਦੇ ਹਨ।
ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਸੂਚੀ ਮਿਕਸਡ ਕਿਸਮਾਂ ਦੀਆਂ ਵਸਤੂਆਂ ਦਾ ਇੱਕ ਕ੍ਰਮਬੱਧ ਸੰਗ੍ਰਹਿ ਹੈ ਜਿਸਨੂੰ ਸੋਧਿਆ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਜਿਨ੍ਹਾਂ ਦੀਆਂ ਵਸਤੂਆਂ ਵੱਖਰੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ।
ਇਸਦਾ ਮਤਲੱਬ ਕੀ ਹੈ? ਆਉ ਵਿਸਥਾਰ ਵਿੱਚ ਪਰਿਭਾਸ਼ਾ 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰੀਏ.
ਸੂਚੀ ਦਾ ਆਕਾਰ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਘਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਇਸ ਵਿੱਚ ਨਵੀਆਂ ਲਾਈਨਾਂ ਜੋੜੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ। ਤੁਸੀਂ ਸੂਚੀ ਦੇ ਪੂਰੇ ਢਾਂਚੇ ਨੂੰ ਵੀ ਬਦਲ ਸਕਦੇ ਹੋ। ਧਿਆਨ ਵਿੱਚ ਰੱਖੋ ਕਿ ਜਦੋਂ ਵੀ ਇੱਕ ਸੂਚੀ ਵਿੱਚ ਕੋਈ ਵਿਧੀ ਵਰਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਅਸਲ ਸੂਚੀ ਬਦਲ ਜਾਂਦੀ ਹੈ, ਕਾਪੀ ਨਹੀਂ।
ਵਧੇਰੇ ਸਪਸ਼ਟਤਾ ਲਈ, ਤੁਸੀਂ ਪਾਇਥਨ ਵਿੱਚ ਇੱਕ ਸੂਚੀ ਨੂੰ ਉਹਨਾਂ ਉਤਪਾਦਾਂ ਦੀ ਸੂਚੀ ਦੇ ਰੂਪ ਵਿੱਚ ਸੋਚ ਸਕਦੇ ਹੋ ਜਿਹਨਾਂ ਨੂੰ ਸਟੋਰ ਵਿੱਚ ਖਰੀਦਣ ਦੀ ਲੋੜ ਹੈ। ਜੇਕਰ, ਇੱਕ ਖਰੀਦਦਾਰੀ ਯੋਜਨਾ ਬਣਾਉਂਦੇ ਸਮੇਂ, ਸਾਰੀਆਂ ਜ਼ਰੂਰੀ ਚੀਜ਼ਾਂ ਇੱਕ ਦੂਜੇ ਦੇ ਹੇਠਾਂ ਸਥਿਤ ਹੁੰਦੀਆਂ ਹਨ, ਅਤੇ ਉਹਨਾਂ ਵਿੱਚੋਂ ਹਰ ਇੱਕ ਦੀ ਆਪਣੀ ਲਾਈਨ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਪਾਈਥਨ ਵਿੱਚ ਸੂਚੀ ਵਿੱਚ ਕਾਮਿਆਂ ਅਤੇ ਵਰਗ ਬਰੈਕਟਾਂ ਵਿੱਚ ਵੱਖ ਕੀਤੇ ਸਾਰੇ ਤੱਤ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ ਤਾਂ ਜੋ ਪਾਈਥਨ ਸਮਝ ਸਕੇ ਕਿ ਇੱਕ ਸੂਚੀ ਇੱਥੇ ਦਰਸਾਈ ਗਈ ਹੈ। ਤੱਤ ਹਵਾਲਾ ਚਿੰਨ੍ਹ ਵਿੱਚ ਬੰਦ ਹਨ। ਇਹ ਇੱਕ ਲਾਜ਼ਮੀ ਸ਼ਰਤ ਹੈ, ਕਿਉਂਕਿ ਹਰੇਕ ਤੱਤ ਇੱਕ ਵੱਖਰੀ ਲਾਈਨ ਹੈ।
ਇੱਕ ਸੂਚੀ ਬਣਾਉਣ ਦੇ ਤਰੀਕੇ
ਕਲਾਸਿਕ ਉਦਾਹਰਨ ਵੱਲ ਵਧਦੇ ਹੋਏ, ਆਓ ਇੱਕ ਸੂਚੀ ਬਣਾਈਏ ਜੋ ਅਸੀਂ ਭਵਿੱਖ ਵਿੱਚ ਵਰਤਾਂਗੇ ਅਤੇ ਸੰਸ਼ੋਧਿਤ ਕਰਾਂਗੇ। ਸੂਚੀਆਂ ਬਣਾਉਣ ਦੇ ਕਈ ਤਰੀਕੇ ਹਨ।
ਉਨ੍ਹਾਂ ਵਿੱਚੋਂ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਹੈ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਸੂਚੀ (). ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਕਿਸੇ ਵੀ ਵਸਤੂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਜਿਸ ਨੂੰ ਦੁਹਰਾਇਆ ਜਾ ਸਕਦਾ ਹੈ (ਇੱਕ ਸਤਰ, ਇੱਕ ਟੂਪਲ, ਜਾਂ ਇੱਕ ਮੌਜੂਦਾ ਸੂਚੀ)। ਇਸ ਮਾਮਲੇ ਵਿੱਚ, ਇੱਕ ਸਤਰ.
ਇੱਥੇ ਅੰਤ ਵਿੱਚ ਕੀ ਹੁੰਦਾ ਹੈ:
>>> ਸੂਚੀ('ਸੂਚੀ') ['c', 'n', 'i', 'c', 'o', 'to']ਦੂਜੀ ਉਦਾਹਰਣ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਸੂਚੀਆਂ ਵਿੱਚ ਬਹੁਤ ਸਾਰੀਆਂ ਵੱਖਰੀਆਂ ਵਸਤੂਆਂ ਦੀ ਅਸੀਮਿਤ ਗਿਣਤੀ ਸ਼ਾਮਲ ਹੋ ਸਕਦੀ ਹੈ। ਨਾਲ ਹੀ, ਸੂਚੀ ਖਾਲੀ ਰਹਿ ਸਕਦੀ ਹੈ।
>>> s = [] # ਖਾਲੀ ਸੂਚੀ >>> l = ['s', 'p', ['isok'], 2] >>> s [] >>> l ['s', 'p' , ['ਇਸੋਕ'], 2]
ਸੂਚੀ ਬਣਾਉਣ ਦਾ ਅਗਲਾ, ਤੀਜਾ, ਤਰੀਕਾ ਅਖੌਤੀ ਹੈ ਸੂਚੀ ਜਨਰੇਟਰ.
ਲਿਸਟਿੰਗ ਜਨਰੇਟਰ ਸੂਚੀਆਂ ਬਣਾਉਣ ਲਈ ਇੱਕ ਸਿੰਟੈਕਟਿਕ ਨਿਰਮਾਣ ਹੈ। ਇਹ ਲੂਪ ਲਈ ਸਮਾਨ ਹੈ।
>>> c = [c * 3 'ਲਿਸਟ' ਵਿੱਚ c ਲਈ] >>> c ['lll', 'iii', 'sss', 'ttt']
ਇਸਦੀ ਵਰਤੋਂ ਹੋਰ ਵਿਸ਼ਾਲ ਢਾਂਚੇ ਬਣਾਉਣ ਲਈ ਵੀ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ:
>>> c = [c * 3 for c in 'list' if c!= 'i'] >>> c ['lll', 'sss', 'ttt'] >>> c = [c + d ਲਈ c in 'list' if c!= 'i' for d in 'spam' if d!= 'a'] >>> c ['ls', 'lp', 'lm', 'ss', 'sp'. , 'sm', 'ts', 'tp', 'tm']
ਹਾਲਾਂਕਿ, ਕਈ ਸੂਚੀਆਂ ਨੂੰ ਕੰਪਾਇਲ ਕਰਨ ਵੇਲੇ ਇਹ ਪੀੜ੍ਹੀ ਵਿਧੀ ਹਮੇਸ਼ਾਂ ਕੁਸ਼ਲ ਨਹੀਂ ਹੁੰਦੀ ਹੈ। ਇਸ ਲਈ, ਸੂਚੀਆਂ ਬਣਾਉਣ ਲਈ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਸਲਾਹ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ।
ਜੇਕਰ ਤੁਹਾਨੂੰ ਸੂਚੀ ਵਿੱਚੋਂ ਕਿਸੇ ਤੱਤ ਦਾ ਹਵਾਲਾ ਦੇਣ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਸੂਚਕਾਂਕ ਵਰਤੇ ਜਾਂਦੇ ਹਨ। ਹਰੇਕ ਤੱਤ ਦਾ ਆਪਣਾ ਸੂਚਕਾਂਕ ਹੁੰਦਾ ਹੈ।
ਸੂਚਕਾਂਕ ਸੂਚੀ ਵਿੱਚ ਤੱਤ ਦੀ ਸੰਖਿਆ ਹੈ।
ਜੇਕਰ ਤੁਸੀਂ ਸੂਚੀ ਨੂੰ ਦੁਹਰਾਉਣ ਵਾਲੇ, ਇੱਕੋ ਜਿਹੇ ਤੱਤਾਂ ਨਾਲ ਭਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ * ਚਿੰਨ੍ਹ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਸੂਚੀ ਵਿੱਚ ਤਿੰਨ ਇੱਕੋ ਜਿਹੇ ਨੰਬਰ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ: [100] * 3.
ਸੂਚੀਕਰਨ ਫੰਕਸ਼ਨ
ਫੰਕਸ਼ਨ - ਇਹ ਸ਼ਾਇਦ ਹੋਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਨਾਲੋਂ ਪਾਈਥਨ ਦਾ ਮੁੱਖ ਫਾਇਦਾ ਹੈ। ਬੁਨਿਆਦੀ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਸੂਚੀਆਂ 'ਤੇ ਲਾਗੂ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ।
ਉਹਨਾਂ ਵਿੱਚੋਂ ਸਭ ਤੋਂ ਮਸ਼ਹੂਰ ਵਿਚਾਰ ਕਰੋ:
- ਸੂਚੀ(ਸੀਮਾ()) - ਜੇਕਰ ਕੰਮ ਇੱਕ ਕ੍ਰਮਵਾਰ ਸੂਚੀ ਬਣਾਉਣਾ ਹੈ, ਤਾਂ ਰੇਂਜ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਫੰਕਸ਼ਨ ਦੇ ਹੇਠ ਲਿਖੇ ਰੂਪ ਹਨ:
- ਸੀਮਾ (ਅੰਤ) ਇਹ ਉਦੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਜ਼ੀਰੋ ਤੋਂ ਇੱਕ ਸੀਮਿਤ ਸੰਖਿਆ ਤੱਕ ਇੱਕ ਸੂਚੀ ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਹੁੰਦਾ ਹੈ।
- ਸੀਮਾ (ਸ਼ੁਰੂ, ਅੰਤ)। ਦੋਨੋ ਸ਼ੁਰੂਆਤੀ ਅਤੇ ਅੰਤ ਨੰਬਰ ਨਿਰਦਿਸ਼ਟ ਹਨ.
- ਸੀਮਾ (ਸ਼ੁਰੂ, ਅੰਤ, ਕਦਮ)। ਕਦਮ ਪੈਰਾਮੀਟਰ ਚੋਣ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਤੁਹਾਨੂੰ 1 ਤੋਂ 21 ਤੱਕ ਦੇ ਕ੍ਰਮ ਵਿੱਚੋਂ ਹਰ ਪੰਜਵੇਂ ਨੰਬਰ ਦੀ ਚੋਣ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਨਤੀਜਾ ਸੂਚੀ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗੀ: [10,15, 20]।
ਰੇਂਜ ਫੰਕਸ਼ਨ ਕੋਡ ਦੀ ਮਾਤਰਾ ਨੂੰ ਕਾਫ਼ੀ ਘਟਾ ਸਕਦਾ ਹੈ।
- ਫਲੈਕਸ (ਸੂਚੀ) - ਤੁਹਾਨੂੰ ਇਹ ਪਤਾ ਲਗਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ ਕਿ ਸੂਚੀ ਵਿੱਚ ਕਿੰਨੇ ਤੱਤ ਹਨ.
- ਕ੍ਰਮਬੱਧ (ਸੂਚੀ, [ਕੁੰਜੀ]) - ਸੂਚੀ ਵਿੱਚ ਵਸਤੂਆਂ ਨੂੰ ਵਧਦੇ ਕ੍ਰਮ ਵਿੱਚ ਕ੍ਰਮਬੱਧ ਕਰਦਾ ਹੈ।
- ਅਧਿਕਤਮ (ਸੂਚੀ) - ਸਭ ਤੋਂ ਵੱਡਾ ਤੱਤ ਵਾਪਸ ਕਰਦਾ ਹੈ।
- ਮਿੰਟ (ਸੂਚੀ) - ਉਲਟ ਫੰਕਸ਼ਨ - ਤੁਹਾਨੂੰ ਘੱਟੋ-ਘੱਟ ਮੁੱਲ ਦੇ ਨਾਲ ਤੱਤ ਵਾਪਸ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।
ਤੁਸੀਂ ਹੋਰ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ:
- ਸੂਚੀ (ਟੱਪਲ) - ਇੱਕ ਟੂਪਲ ਆਬਜੈਕਟ ਨੂੰ ਇੱਕ ਸੂਚੀ ਵਿੱਚ ਬਦਲਦਾ ਹੈ।
- ਜੋੜ (ਸੂਚੀ) - ਸੂਚੀ ਵਿੱਚ ਸਾਰੇ ਤੱਤਾਂ ਨੂੰ ਜੋੜਦਾ ਹੈ ਜੇਕਰ ਸਾਰੇ ਮੁੱਲ ਸੰਖਿਆਵਾਂ ਹਨ, ਪੂਰਨ ਅੰਕ ਅਤੇ ਦਸ਼ਮਲਵ ਦੋਵਾਂ 'ਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਉਹ ਹਮੇਸ਼ਾ ਇਸ ਨੂੰ ਸਹੀ ਨਹੀਂ ਕਰਦੀ। ਜੇਕਰ ਸੂਚੀ ਵਿੱਚ ਇੱਕ ਗੈਰ-ਸੰਖਿਆਤਮਕ ਤੱਤ ਹੈ, ਤਾਂ ਫੰਕਸ਼ਨ ਇੱਕ ਗਲਤੀ ਸੁੱਟੇਗਾ: "TypeError: +: 'int' ਅਤੇ 'str' ਲਈ ਅਸਮਰਥਿਤ ਓਪਰੇਂਡ ਕਿਸਮ"।
ਸੂਚੀਕਰਨ ਢੰਗ
ਆਓ ਸਟੋਰ ਵਿੱਚ ਖਰੀਦਣ ਲਈ ਸਾਡੀਆਂ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ 'ਤੇ ਵਾਪਸ ਚੱਲੀਏ ਅਤੇ ਇਸਨੂੰ ਸ਼ਾਪਲਿਸਟ ਕਹਿੰਦੇ ਹਾਂ:
ਦੁਕਾਨ ਦੀ ਸੂਚੀ = []
ਅੱਗੇ, ਸੂਚੀਕਰਨ ਵਿਧੀਆਂ 'ਤੇ ਵਿਚਾਰ ਕਰੋ:
- ਜੋੜ (ਆਈਟਮ) - ਇਸਦੀ ਮਦਦ ਨਾਲ, ਤੁਸੀਂ ਸੂਚੀ ਵਿੱਚ ਇੱਕ ਤੱਤ ਸ਼ਾਮਲ ਕਰ ਸਕਦੇ ਹੋ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਨਵਾਂ ਤੱਤ ਅੰਤ ਵਿੱਚ ਹੋਵੇਗਾ।
ਆਓ ਆਪਣੀ ਨਵੀਂ ਸੂਚੀ ਨੂੰ ਸਹੀ ਉਤਪਾਦਾਂ ਨਾਲ ਭਰੀਏ:
shoplist.append(ਰੋਟੀ)
shoplist.append(ਦੁੱਧ)
- ਸੂਚੀ ਹੈ.ਵਿਸਤਾਰ(A) - "ਸੂਚੀ ਵਿੱਚ ਸੂਚੀ" ਜੋੜਦਾ ਹੈ. ਇਹ ਵਿਸ਼ੇਸ਼ਤਾ ਸਮੇਂ ਦੀ ਬਚਤ ਕਰਦੀ ਹੈ ਕਿਉਂਕਿ ਤੁਸੀਂ ਇੱਕੋ ਸਮੇਂ ਕਈ ਆਈਟਮਾਂ ਜੋੜ ਸਕਦੇ ਹੋ। ਮੰਨ ਲਓ ਕਿ ਸਾਡੇ ਕੋਲ ਪਹਿਲਾਂ ਹੀ ਫਲਾਂ ਦੀ ਸੂਚੀ ਹੈ, ਸਾਨੂੰ ਉਹਨਾਂ ਨੂੰ ਮੁੱਖ ਸੂਚੀ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ.
shoplist.extend(ਫਲ)
- ਸੰਮਿਲਿਤ ਕਰੋ (ਸੂਚਕਾਂਕ, ਆਈਟਮ) - ਨਿਰਧਾਰਿਤ ਸੂਚਕਾਂਕ ਦੇ ਨਾਲ ਤੱਤ 'ਤੇ ਨਿਰਧਾਰਤ ਸੂਚਕਾਂਕ ਤੋਂ ਪਹਿਲਾਂ ਨਿਰਧਾਰਤ ਮੁੱਲ ਨੂੰ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ।
- ਗਿਣਤੀ (ਆਈਟਮ) - ਤੱਤ ਦੇ ਦੁਹਰਾਓ ਦੀ ਸੰਖਿਆ ਦਿਖਾਉਂਦਾ ਹੈ।
- ਸੂਚੀ ਹੈ.ਹਟਾਓ(ਆਈਟਮ) ਉਲਟ ਫੰਕਸ਼ਨ ਹੈ ਸੂਚੀ ਹੈ.ਜੋੜੋ (x). ਇਹ ਕਿਸੇ ਵੀ ਤੱਤ ਨੂੰ ਹਟਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ. ਜੇ ਚੁਣੀ ਆਈਟਮ ਸੂਚੀ ਵਿੱਚ ਨਹੀਂ ਹੈ, ਤਾਂ ਇੱਕ ਗਲਤੀ ਦੀ ਰਿਪੋਰਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
- ਪੌਪ([ਸੂਚਕਾਂਕ]) - ਚੁਣੇ ਹੋਏ ਤੱਤ ਨੂੰ ਹਟਾਉਂਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਉਸੇ ਤਰੀਕੇ ਨਾਲ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਤੱਤ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਆਖਰੀ ਤੱਤ ਸੂਚੀ ਵਿੱਚੋਂ ਹਟਾ ਦਿੱਤਾ ਜਾਵੇਗਾ।
- ਲੜੀਬੱਧ ([ਕੁੰਜੀ]) - ਸੂਚੀ ਵਿੱਚ ਤੱਤਾਂ ਨੂੰ ਵਧਦੇ ਕ੍ਰਮ ਵਿੱਚ ਰੱਖਦਾ ਹੈ, ਪਰ ਤੁਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ ਵੀ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ।
- ਸੂਚਕਾਂਕ(ਆਈਟਮ) - ਪਹਿਲੇ ਚੁਣੇ ਹੋਏ ਤੱਤ ਦਾ ਸੂਚਕਾਂਕ ਦਿਖਾਉਂਦਾ ਹੈ।
- ਤੁਸੀਂ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸੂਚੀ ਨੂੰ ਵਧਾ ਸਕਦੇ ਹੋ, ਯਾਨੀ ਇਸਦੇ ਸਾਰੇ ਤੱਤਾਂ ਨੂੰ ਮਿਰਰ ਕਰੋ ਉਲਟਾ (ਸੂਚੀ). ਆਖਰੀ ਤੱਤ ਪਹਿਲਾ ਬਣ ਜਾਂਦਾ ਹੈ, ਅੰਤਮ ਤੱਤ ਦੂਜਾ ਬਣ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਹੋਰ ਵੀ।
- ਕਮਾਂਡ ਨਾਲ ਸੂਚੀ ਦੀ ਇੱਕ ਕਾਪੀ ਬਣਾਈ ਜਾਂਦੀ ਹੈ ਕਾਪੀ(ਸੂਚੀ).
- ਦੀਪ ਕਾਪੀ (ਸੂਚੀ) - ਡੂੰਘੀ ਨਕਲ.
- ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸੂਚੀਕਰਨ ਦੇ ਸਾਰੇ ਤੱਤ ਹਟਾਓ ਸਾਫ਼ (ਸੂਚੀ).
ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ ਸੂਚੀਕਰਨ ਵਿਧੀਆਂ ਸਟ੍ਰਿੰਗ ਵਿਧੀਆਂ ਤੋਂ ਵੱਖਰੀਆਂ ਹਨ ਕਿਉਂਕਿ ਉਹ ਸੂਚੀ ਨੂੰ ਤੁਰੰਤ ਬਦਲ ਦਿੰਦੇ ਹਨ, ਯਾਨੀ, ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੇ ਨਤੀਜੇ ਨੂੰ ਵਾਪਸ ਕਰਨ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ।
>>> l = [1, 2, 3, 5, 7] >>> l.sort() >>> l [1, 2, 3, 5, 7] >>> l = l.sort() > >> ਪ੍ਰਿੰਟ(l) ਕੋਈ ਨਹੀਂ
ਹੇਠਾਂ ਸੂਚੀਆਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ:
>>> a = [66.25, 333, 333, 1, 1234.5] >>> ਪ੍ਰਿੰਟ(a.count(333), a.count(66.25), a.count('x')) 2 1 0 >>> a.insert(2, -1) >>> a.append(333) >>> a [66.25, 333, -1, 333, 1, 1234.5, 333] >>> a.index(333) 1 >> > a.remove(333) >>> a [66.25, -1, 333, 1, 1234.5, 333] >>> a.reverse() >>> a [333, 1234.5, 1, 333, -1, 66.25 ] >>> a.sort() >>> a [-1, 1, 66.25, 333, 333, 1234.5]