ਪਾਈਥਨ ਵਿੱਚ ਲੂਪ ਲਈ। ਸੰਟੈਕਸ, ਸੂਚੀ ਦੁਹਰਾਓ, ਬਰੇਕ, ਜਾਰੀ ਰੱਖੋ ਅਤੇ ਹੋਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ

Цpython i ਲਈ ikl ਚੱਕਰ ਜਦਕਿ - ਬਿਆਨ ਸਾਫਟਵੇਅਰ ਭਾਸ਼ਾ, ਅਰਥਾਤ: iteration ਆਪਰੇਟਰ, letIng ਕੋਡ ਦੁਹਰਾਓ ਦਿੱਤਾ ਨੰਬਰ ਸਮਾਂ

Цਲਈ - сintaxis

ਜਿਵੇਂ ਕਿ ਪਹਿਲਾਂ ਹੀ ਸਮਝਾਇਆ ਗਿਆ ਹੈ, ਸੀਪਾਈਥਨ ਵਿੱਚ ਸ਼ਾਮਲ ਲਈ ਇੱਕ ਇਟਰੇਟਰ ਅਧਾਰਤ ਹੈй ਪ੍ਰਤੀ ਚੱਕਰਪਛਾਣ. ਉਹ ਹੈ ਕੰਮ tuple ਤੱਤ ਦੁਆਰਾ и ਸੂਚੀ, ਸ਼ਬਦਾਵਲੀ ਕੁੰਜੀਆਂ ਅਤੇ ਹੋਰ ਦੁਹਰਾਉਣਯੋਗ ਵਸਤੂਆਂ।

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

ਵਿੱਚ ਲਈ: else:      

ਭਾਗ "ਕ੍ਰਮ" ਸੂਚੀਬੱਧ ਹਨ ਇੱਕ ਦੇ ਬਾਅਦ ਇੱਕ ਚੱਕਰ ਵੇਰੀਏਬਲ. ਜਾਂ ਸਗੋਂ, ਨੂੰ ਵੇਰੀਏਬਲ ਪੁਆਇੰਟ ਅਜਿਹੇ ਤੱਤ. ਹਰ ਕਿਸੇ ਲਈ ਉਹਣਾਂ ਵਿੱਚੋਂ "ਕਾਰਵਾਈ" ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਇੱਕ ਖਾਸ ਉਦਾਹਰਣ ਦੇ ਨਾਲ ਪਾਈਥਨ ਵਿੱਚ ਲੂਪ ਲਈ ਇੱਕ ਸਧਾਰਨ:

>>> ਭਾਸ਼ਾਵਾਂ = ["C", "C++", "Perl", "Python"] >>> ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ x ਲਈ: ... ਪ੍ਰਿੰਟ(x) ... C C++ ਪਰਲ ਪਾਈਥਨ >>>

ਬਾਕੀ ਬਲਾਕ ਵਿਸ਼ੇਸ਼ ਹੈth ਜੇਕਰ ਏ ਪ੍ਰੋਗਰਾਮ ਦੇыਕੰਮ ਕਰ с ਪਰਲ ਜਾਣੂы ਉਸਦੇ ਨਾਲ, ਹੈ, ਜੋ ਕਿ ਉਹਨਾਂ ਲਈ ਜੋ ਗੱਲਬਾਤ ਕਰਦੇ ਹਨ с C ਅਤੇ C++ — ਇਹ ਇੱਕ ਨਵੀਨਤਾ ਹੈ. ਅਰਥਪੂਰਨ ਤੌਰ 'ਤੇ ਇਹ ਫੰਕਸ਼ਨ тਸਮਾਨ ਰੂਪ ਵਿੱਚ ਲੂਪ ਦੌਰਾਨ.

ਸਿਰਫ਼ ਉਦੋਂ ਹੀ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਬਰੇਕ ਸਟੇਟਮੈਂਟ ਦੁਆਰਾ ਲੂਪ ਨੂੰ "ਰੋਕਿਆ" ਨਹੀਂ ਜਾਂਦਾ ਹੈ। ਯਾਨੀ, ਇਹ ਸਾਰੇ ਤੱਤ ਨਿਰਧਾਰਤ ਕ੍ਰਮ ਵਿੱਚੋਂ ਲੰਘਣ ਤੋਂ ਬਾਅਦ ਹੀ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ।

ਪਾਈਥਨ ਵਿੱਚ ਬ੍ਰੇਕ ਓਪਰੇਟਰ - ਬ੍ਰੇਕ

ਜੇਕਰ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਲੂਪ ਲਈ ਇੱਕ ਹੈ ਜ਼ਰੂਰੀ ਵਿਘਨThe ਬਰੇਕ ਸਟੇਟਮੈਂਟ, he ਮੁਕੰਮਲ ਹੋਇਹ ਚਲਾ ਜਾਂਦਾ ਹੈਅਤੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਵਹਿਣਾ ਕਰੇਗਾ CONTਹੋਣ ਵਾਲਾ ਬਿਨਾ ਸਰਗਰਮ ਹੋਰ ਤੋਂ।

ਹੋਰ ਅਕਸਰ python ਵਿੱਚ ਵਾਕਾਂਸ਼ਾਂ ਨੂੰ ਤੋੜੋuyutsya ਸ਼ਰਤੀਆ ਬਿਆਨ ਦੇ ਨਾਲ.

edibles = ["ਚੌਪਸ", "ਡੰਪਲਿੰਗ","ਐਗਜ਼","ਨਟਸ"] ਖਾਣ ਵਾਲੀਆਂ ਚੀਜ਼ਾਂ ਵਿੱਚ ਭੋਜਨ ਲਈ: ਜੇਕਰ ਭੋਜਨ == "ਡੰਪਲਿੰਗ": ਪ੍ਰਿੰਟ ("ਮੈਂ ਡੰਪਲਿੰਗ ਨਹੀਂ ਖਾਂਦਾ!") ਬ੍ਰੇਕ ਪ੍ਰਿੰਟ ("ਸ਼ਾਨਦਾਰ, ਸੁਆਦੀ " + ਭੋਜਨ) ਹੋਰ: ਪ੍ਰਿੰਟ ("ਇਹ ਚੰਗਾ ਹੈ ਕਿ ਕੋਈ ਡੰਪਲਿੰਗ ਨਹੀਂ ਸਨ!") ਪ੍ਰਿੰਟ ("ਡਿਨਰ ਖਤਮ ਹੋ ਗਿਆ ਹੈ।")

ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਕੋਡ ਨੂੰ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਨਤੀਜੇ ਪ੍ਰਾਪਤ ਹੁੰਦੇ ਹਨ:

ਸ਼ਾਨਦਾਰ, ਸੁਆਦੀ ਚੋਪ. ਮੈਂ ਡੰਪਲਿੰਗ ਨਹੀਂ ਖਾਂਦਾ! ਰਾਤ ਦਾ ਖਾਣਾ ਖਤਮ ਹੋ ਗਿਆ ਹੈ।

ਅਸੀਂ ਡੇਟਾ ਦੀ ਮੌਜੂਦਾ ਸੂਚੀ ਵਿੱਚੋਂ "ਡੰਪਲਿੰਗ" ਨੂੰ ਹਟਾਉਂਦੇ ਹਾਂ ਅਤੇ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ:

ਸ਼ਾਨਦਾਰ, ਸੁਆਦੀ ਚੋਪਸ ਸ਼ਾਨਦਾਰ, ਸੁਆਦੀ ਅੰਡੇ ਸ਼ਾਨਦਾਰ, ਸੁਆਦੀ ਗਿਰੀਦਾਰ ਚੰਗੀ ਗੱਲ ਇਹ ਹੈ ਕਿ ਕੋਈ ਡੰਪਲਿੰਗ ਨਹੀਂ ਸਨ! ਰਾਤ ਦਾ ਖਾਣਾ ਖਤਮ ਹੋ ਗਿਆ ਹੈ।

python skip operator – ਜਾਰੀ ਰੱਖੋ

ਦੱਸ ਦਈਏ ਕਿ ਅਜਿਹੇ ਉਤਪਾਦਾਂ ਪ੍ਰਤੀ ਉਪਭੋਗਤਾ ਦੀ ਵਿਰੋਧੀ ਭਾਵਨਾ ਇੰਨੀ ਵੱਡੀ ਨਹੀਂ ਹੈ ਕਿ ਉਨ੍ਹਾਂ ਦੀ ਖਪਤ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਛੱਡ ਦਿੱਤਾ ਜਾਵੇ। ਨਤੀਜੇ ਵਜੋਂ, ਆਪਰੇਟਰ ਨਾਲ ਲੂਪ ਜਾਰੀ ਰਹਿੰਦਾ ਹੈ continue. ਹੇਠ ਦਿੱਤੀ ਸਕ੍ਰਿਪਟ ਬਿਆਨ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ continue, "ਡੰਪਲਿੰਗ ਸੰਪਰਕ" 'ਤੇ ਸੂਚੀ ਰਾਹੀਂ ਦੁਹਰਾਉਣਾ ਜਾਰੀ ਰੱਖਣ ਲਈ।

edibles = ["ਚੌਪਸ", "ਡੰਪਲਿੰਗ","ਐਗਜ਼","ਨਟਸ"] ਖਾਣ ਵਾਲੀਆਂ ਚੀਜ਼ਾਂ ਵਿੱਚ ਭੋਜਨ ਲਈ: ਜੇਕਰ ਭੋਜਨ == "ਡੰਪਲਿੰਗ": ਪ੍ਰਿੰਟ ("ਮੈਂ ਡੰਪਲਿੰਗ ਨਹੀਂ ਖਾਂਦਾ!") ਪ੍ਰਿੰਟ ਜਾਰੀ ਰੱਖੋ("ਸ਼ਾਨਦਾਰ, ਸੁਆਦੀ " + ਭੋਜਨ) # ਇਹ ਭੋਜਨ ਦਾ ਅਨੰਦ ਲੈਣ ਲਈ ਕੋਡ ਹੋ ਸਕਦਾ ਹੈ :-) ਹੋਰ: ਪ੍ਰਿੰਟ ("ਮੈਨੂੰ ਡੰਪਲਿੰਗਾਂ ਤੋਂ ਨਫ਼ਰਤ ਹੈ!") ਪ੍ਰਿੰਟ ("ਡਿਨਰ ਖਤਮ ਹੋ ਗਿਆ ਹੈ।")

ਤਲ ਲਾਈਨ:

ਸ਼ਾਨਦਾਰ, ਸੁਆਦੀ ਚੋਪ. ਮੈਂ ਡੰਪਲਿੰਗ ਨਹੀਂ ਖਾਂਦਾ! ਸ਼ਾਨਦਾਰ, ਸੁਆਦੀ ਅੰਡੇ ਸ਼ਾਨਦਾਰ, ਸੁਆਦੀ ਗਿਰੀਦਾਰ ਮੈਨੂੰ ਡੰਪਲਿੰਗਾਂ ਤੋਂ ਨਫ਼ਰਤ ਹੈ! ਰਾਤ ਦਾ ਖਾਣਾ ਖਤਮ ਹੋ ਗਿਆ ਹੈ।

ਰੇਂਜ() ਫੰਕਸ਼ਨ ਨਾਲ ਸੂਚੀਆਂ ਉੱਤੇ ਦੁਹਰਾਉਣਾ

ਜੇਕਰ ਤੁਸੀਂ ਸੂਚੀ ਦੇ ਸੂਚਕਾਂਕ ਤੱਕ ਪਹੁੰਚ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇਹ ਸਪਸ਼ਟ ਨਹੀਂ ਹੈ ਕਿ ਇਸ ਉਦੇਸ਼ ਲਈ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ। ਸਾਰੇ ਤੱਤਾਂ ਤੱਕ ਪਹੁੰਚ ਕਰਨਾ ਸੰਭਵ ਹੈ, ਪਰ ਤੱਤ ਦਾ ਸੂਚਕਾਂਕ ਪਹੁੰਚ ਤੋਂ ਬਾਹਰ ਰਹੇਗਾ। ਹਾਲਾਂਕਿ, ਤੱਤ ਦੇ ਸੂਚਕਾਂਕ ਅਤੇ ਤੱਤ ਆਪਣੇ ਆਪ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ ਹੈ। ਇਸ ਮਕਸਦ ਲਈ, ਫੰਕਸ਼ਨ ਵਰਤਿਆ ਗਿਆ ਹੈ range() ਲੰਬਾਈ ਫੰਕਸ਼ਨ ਦੇ ਨਾਲ ਮਿਲਾ ਕੇ len():

fibonacci = [0,1,1,2,3,5,8,13,21] ਰੇਂਜ ਵਿੱਚ i ਲਈ(len(fibonacci)): print(i,fibonacci[i])

ਪ੍ਰਾਪਤ ਕਰੋ:

0 0 1 1 2 1 3 2 4 3 5 5 6 8 7 13 8 21 XNUMX XNUMX

ਧਿਆਨ ਦਿਓ! ਜਦੋਂ ਲਾਗੂ ਹੁੰਦਾ ਹੈ len() к list or tuple, ਦਿੱਤੇ ਗਏ ਕ੍ਰਮ ਦੇ ਤੱਤਾਂ ਦੀ ਅਨੁਸਾਰੀ ਸੰਖਿਆ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਸੂਚੀਆਂ ਨੂੰ ਦੁਹਰਾਉਣ ਵਿੱਚ ਮੁਸ਼ਕਲਾਂ

ਜਦੋਂ ਇੱਕ ਸੂਚੀ ਨੂੰ ਦੁਹਰਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਲੂਪ ਬਾਡੀ ਵਿੱਚ ਸੂਚੀ ਦੀ ਗਤੀਸ਼ੀਲਤਾ ਤੋਂ ਬਚਣ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਸਪਸ਼ਟਤਾ ਲਈ, ਅਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਵਿਕਲਪ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰ ਸਕਦੇ ਹਾਂ:

ਰੰਗ = ["ਲਾਲ"] ਰੰਗਾਂ ਵਿੱਚ i ਲਈ: ਜੇਕਰ i == "ਲਾਲ": ਰੰਗ += ["ਕਾਲਾ"] ਜੇਕਰ i == "ਕਾਲਾ": ਰੰਗ += ["ਚਿੱਟਾ"] ਪ੍ਰਿੰਟ(ਰੰਗ)

ਅਰਜ਼ੀ ਦੇਣ ਵੇਲੇ ਕੀ ਹੁੰਦਾ ਹੈ print(colours)?

['ਲਾਲ', 'ਕਾਲਾ', 'ਚਿੱਟਾ']

ਇਸ ਤੋਂ ਬਚਣ ਲਈ, ਟੁਕੜਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਾਪੀ ਨਾਲ ਗੱਲਬਾਤ ਕਰਨ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਹੇਠਾਂ ਦਿੱਤੀ ਉਦਾਹਰਣ ਵਿੱਚ:

ਰੰਗ = ["ਲਾਲ"] ਰੰਗਾਂ ਵਿੱਚ i ਲਈ[:]: ਜੇਕਰ i == "ਲਾਲ": ਰੰਗ += ["ਕਾਲਾ"] ਜੇਕਰ i == "ਕਾਲਾ": ਰੰਗ += ["ਚਿੱਟਾ"] ਪ੍ਰਿੰਟ(ਰੰਗ )

ਨਤੀਜਾ:

['ਲਾਲ ਕਾਲਾ']

ਸੂਚੀ ਬਦਲ ਦਿੱਤੀ ਗਈ ਹੈ colours, ਪਰ ਇਸ ਕਾਰਵਾਈ ਨੇ ਲੂਪ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਨਹੀਂ ਕੀਤਾ। ਲੂਪ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੌਰਾਨ ਜੋ ਡਾਟਾ ਦੁਹਰਾਉਣ ਦੀ ਲੋੜ ਸੀ ਉਹ ਬਦਲਿਆ ਨਹੀਂ ਰਿਹਾ।

ਪਾਈਥਨ 3 ਵਿੱਚ ਗਿਣੋ

ਗਣਨਾ ਇੱਕ ਬਿਲਟ-ਇਨ ਪਾਈਥਨ ਫੰਕਸ਼ਨ ਹੈ। ਬਹੁਤੇ ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲੇ, ਅਤੇ ਨਾਲ ਹੀ ਕੁਝ ਤਜਰਬੇਕਾਰ ਪ੍ਰੋਗਰਾਮਰ, ਇਸਦੀ ਮੌਜੂਦਗੀ ਤੋਂ ਜਾਣੂ ਨਹੀਂ ਹਨ। ਇਹ ਤੁਹਾਨੂੰ ਆਪਣੇ ਆਪ ਲੂਪ ਦੇ ਦੁਹਰਾਓ ਦੀ ਗਿਣਤੀ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ. ਉਦਾਹਰਣ ਲਈ:

ਕਾਊਂਟਰ ਲਈ, ਗਣਨਾ ਵਿੱਚ ਮੁੱਲ(some_list): ਪ੍ਰਿੰਟ(ਕਾਊਂਟਰ, ਮੁੱਲ)

ਫੰਕਸ਼ਨ enumerate ਇੱਕ ਵਿਕਲਪਿਕ ਆਰਗੂਮੈਂਟ ਵੀ ਲੈਂਦਾ ਹੈ (ਮੂਲ ਦਾ ਮੁੱਲ, ਲਈ ਮੂਲ ਰੂਪ ਵਿੱਚ ਲਿਆ ਜਾਂਦਾ ਹੈ 0). ਜੋ ਇਸਨੂੰ ਹੋਰ ਵੀ ਕੁਸ਼ਲ ਬਣਾਉਂਦਾ ਹੈ।

my_list = ['apple', 'banana', 'cherry', 'peach'] c ਲਈ, ਗਣਨਾ ਵਿੱਚ ਮੁੱਲ(my_list, 1): print(c, value) # ਨਤੀਜਾ: # 1 ਸੇਬ # 2 ਕੇਲਾ # 3 ਚੈਰੀ # 4 ਆੜੂ