ਪਾਇਥਨ ਪਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ: ਲੂਪਸ

ਪਾਇਥਨ ਪਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ (ਦੇ ਤੌਰ ਤੇ "ਪਾਇਥਨ" ਜ "ਪਾਇਥਨ") ਉੱਥੇ ਲੂਪ ਕਰਨ ਦੇ ਕਈ ਤਰੀਕੇ ਕੁਝ ਕਾਰਵਾਈ ਕਰਦੇ ਹਨ. ਪਾਈਥਨ ਵਿੱਚ ਕਿਸੇ ਵੀ ਪੜਾਅ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਮੁੱਖ ਸੰਦ - ਜਦਕਿ ਇਹਨਆ ਅਤੇ. ਜਦਕਿ ਲੂਪ ਲਈ ਵੱਧ ਹੋਰ ਵਿਆਪਕ ਹੁੰਦਾ ਹੈ, ਇਸ ਲਈ ਇਸ ਨੂੰ ਹੌਲੀ ਹੈ. ਪਰ, ਇਸ ਦਾ ਇਹ ਮਤਲਬ ਨਹੀ ਹੈ, ਜੋ ਕਿ ਇਸ ਨੂੰ ਬਿਹਤਰ ਹੈ! ਕਿਉਕਿ ਦੇ ਨਾਲ ਇਸ ਨੂੰ ਬਹੁ-ਪੱਧਰ ਅਤੇ mnogouslovnyh ਪ੍ਰੋਗਰਾਮ ਦੀ ਰਚਨਾ ਲਈ ਸਭ ਮੁਸ਼ਕਲ ਕੰਮ ਨੂੰ ਅਹਿਸਾਸ ਲਈ ਲੂਪ, ਹੋਰ ਅਕਸਰ ਵਰਤਿਆ ਗਿਆ ਹੈ.

ਪਾਇਥਨ: postcondition ਨਾਲ ਚੱਕਰ

postcondition ਨਾਲ ਚੱਕਰ - ਇਸ ਨੂੰ ਇਹਨਆ , ਜਦਕਿ, ਜਿਸ ਵਿਚ ਸਭ ਵਿਆਪਕ ਸੰਗਠਨ ਬਣਤਰ ਹਨ ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਾਤਾਵਰਣ ਨੂੰ. ਜਦਕਿ ਲੂਪ ਦੀ "ਦੇ ਤੌਰ ਤੇ ਦੇ ਤੌਰ ਤੇ ਲੰਬੇ" ਅਸੂਲ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ. ਇਹ ਹੇਠ ਲਿਖੇ ਮਤਲਬ ਹੈ: ਜਦਕਿ ਇੱਕ ਨੂੰ ਕੁਝ ਦੀ ਹਾਲਤ ਇੱਕ ਸੱਚ ਦਾ ਮੁੱਲ ਨੂੰ ਵਾਪਸ ਆ ਜਾਵੇਗਾ, ਇਸ ਨੂੰ ਕੰਮ ਕਰੇਗਾ! ਇਹ ਡਿਜ਼ਾਇਨ ਨੂੰ ਇੱਕ "ਚੱਕਰ" ਕਿਹਾ ਗਿਆ ਹੈ, ਕਿਉਕਿ cyclically ਵਾਰ ਵਾਰ, ਸ਼ੁਰੂਆਤੀ ਮੁੱਲ ਦੇ ਨਾਲ ਸ਼ੁਰੂ ਕਰਨ ਦੇ ਕੰਮ ਪ੍ਰਬੰਧਨ. ਚੱਕਰ ਵਿਚ ਬਾਹਰ ਪਾਇਥਨ ਵਾਰ 'ਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾ ਜਦਕਿ ਇਸ ਦਾ ਮੁੱਲ ਝੂਠੇ ਬਣ ਗਿਆ ਹੈ. ਇਸ ਮੌਕੇ 'ਤੇ, ਦੁਭਾਸ਼ੀਏ ਹੇਠ ਕੰਮ-ਅਰਥ ਹਿੱਸੇ ਨੂੰ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਪ੍ਰਸਾਰਤ, ਇੱਕ ਨਵ ਲਾਈਨ ਹੈ, ਜੋ ਕਿ postcondition ਜਦਕਿ ਨਾਲ ਬਲਾਕ ਦੇ ਬਾਅਦ ਸਥਿਤ ਹੈ ਭਾਵ.

ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਵਿੱਚ, ਪਾਇਥਨ ਚੱਕਰ ਜਦਕਿ postcondition ਹੇਠ ਸੰਟੈਕਸ ਹੈ:

ਇਜ਼ਹਾਰ ਇੱਕ ਸਿੰਗਲ ਬਿਆਨ ਜ ਕਈ ਹੋ ਸਕਦੇ ਹਨ. ਹਾਲਤ ਨੂੰ ਹਮੇਸ਼ਾ ਕਿਸੇ ਵੀ ਗੈਰ-ਜ਼ੀਰੋ ਦੀ ਇੱਕ ਸੱਚ ਮਹੱਤਤਾ ਹੈ. ਇਹ ਡਿਜ਼ਾਇਨ ਦੇ ਤੌਰ ਤੇ ਲੰਬੇ ਦੇ ਤੌਰ ਤੇ ਦਿੱਤੀ ਹਾਲਤ ਸੱਚ ਹੈ ਕੰਮ ਕਰਦਾ ਹੈ.

ਉਦਾਹਰਨ ਲਈ, ਜਦਕਿ "ਪਾਇਥਨ" ਵਿੱਚ ਚੱਕਰ ਦਾ ਇਸਤੇਮਾਲ

ਜਦਕਿ ਲੂਪ Rassmotirim. ਪਾਇਥਨ ਕਾਫ਼ੀ ਦਿਲਚਸਪ ਬਣਤਰ ਇਸ ਦੇ ਦੁਹਰਾ ਹੈ:

ਸਾਨੂੰ ਐਲਾਨ ਕੀਤਾ ਹੈ ਵੇਰੀਏਬਲ "ਇੱਕ" ਅਤੇ ਉਸ ਨੂੰ ਜ਼ੀਰੋ ਕਰਨ ਲਈ ਕਿਹਾ. ਫਿਰ ਹਾਲਾਤ ਸੈਟ ਕਰੋ "ਇੱਕ <7", ਜੋ ਕਿ ਹੈ, ਜਦਕਿ ਵੇਰੀਏਬਲ "ਇੱਕ" ਵੱਧ ਘੱਟ ਹੈ ਨੰਬਰ "7", ਫਿਰ ਸਾਡੇ ਲੂਪ ਦੇ ਤੌਰ ਤੇ ਲੰਬੇ ਝੂਠੇ ਹੁੰਦਾ ਹੈ, ਦੇ ਰੂਪ ਵਿੱਚ ਚਲਾਇਆ ਜਾਵੇਗਾ.

ਇੱਕ ਝੂਠੇ (ਹੈ, ਜੋ ਕਿ ਹੈ, ਚੱਕਰ ਤੱਕ ਬੰਦ ਹੋ ਜਾਵੇਗਾ) ਇਸ ਨੂੰ ਹੋ ਜਾਵੇਗਾ, ਜਦ ਵੇਰੀਏਬਲ ਨੰਬਰ "7" ਵੱਧ ਹੋ ਜਾਵੇਗਾ. ਇਸ ਦਾ ਵਾਪਰਨਾ ਕਰਨ ਲਈ, ਇਸ ਨੂੰ ਹਰ ਵਾਰ 1 ਵੱਧਦਾ ਹੈ, ਜੋ ਕਿ ਸਾਨੂੰ "ਇੱਕ = a + 1" ਵਿੱਚ ਲੱਗਦਾ ਹੈ.

ਤੁਹਾਨੂੰ ਇਸ ਉਸਾਰੀ, ਪੱਤਰ ਨੂੰ ਚਲਾਉਣ ਜੇ "ਇੱਕ" ਇੱਕ ਕਾਲਮ ਵਿੱਚ 7 ਵਾਰ ਦਿਖਾਇਆ ਜਾਵੇਗਾ!

ਬੇਅੰਤ ਲੂਪ ਪਾਈਥਨ ਵਿੱਚ, ਜਦਕਿ

ਕਰਨਾ ਪਾਈਥਨ ਵਿੱਚ ਲਗਾਤਾਰ ਲੂਪ ਬਣਾਉਣ ਲਈ, ਜਦਕਿ? Guess ਮੁਸ਼ਕਲ ਨਹੀ ਹੈ, ਕਿਉਕਿ ਚੱਕਰ, ਜਦ ਤੱਕ, ਜਦ ਤੱਕ ਇਸ ਨੂੰ ਇੱਕ ਗਲਤ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਚੱਲਦਾ ਹੈ, ਅਤੇ ਜੇ ਇਸ ਦਾ ਮੁੱਲ ਸਿਰਫ਼ ਇਸ ਉਥੇ ਨਹੀ ਹੈ? ਸਵਾਲ ਦਾ ਜਵਾਬ ਸੰਭਵ ਹੈ ਹੀ, ਇਸ ਲਈ ਸਭ ਕੁਝ ਸਾਫ ਹੈ. ਕਈ ਵਾਰ, ਇੱਕ ਅਨੰਤ ਲੂਪ ਇੱਕ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ? ਇਹ ਮਿਸਾਲ ਦੇ ਤੌਰ ਤੇ, ਅਜਿਹੇ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਦੇ ਇੱਕ ਬੋਧ ਦੇ ਤੌਰ ਤੇ ਸੇਵਾ ਕਰ ਜਾਵੇਗਾ "ਘੜੀ." ਇੱਥੇ, ਦੇ ਕੋਰਸ, ਤੁਹਾਨੂੰ ਇੱਕ ਅਨੰਤ ਚੱਕਰ ਹੈ, ਜੋ ਕਿ ਸਥਾਈ ਤੌਰ 'ਤੇ ਅੱਪਡੇਟ ਕੀਤਾ ਜਾਵੇਗਾ ਵਰਤਣ ਅਤੇ ਵਾਰ ਦਿਖਾਉਣ ਦੀ ਲੋੜ ਹੈ.

ਅਨੰਤ ਲੂਪ ਅਕਸਰ ਇੱਕ ਗਲਤੀ ਨਿਹਚਾਵਾਨ ਹੈ ਪ੍ਰੋਗਰਾਮਰ ਇੱਕ ਤਬਦੀਲੀ ਚੱਕਰ ਹਾਲਾਤ ਨੂੰ ਸ਼ਾਮਿਲ ਕਰਨ ਲਈ ਭੁੱਲ ਕੌਣ ਹੈ.

ਦੀ ਪਾਇਥਨ ਕੋਡ ਦੇ ਹੇਠ ਟੁਕੜੇ 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਲੈ ਕਰੀਏ. ਇਸ ਕੇਸ ਹਮੇਸ਼ਾ ਲਈ iterated ਵਿਚ ਚੱਕਰ ( "#" ਅੱਖਰ ਦੇ ਬਾਅਦ ਇੱਕ ਟਿੱਪਣੀ ਹੈ):

ਕਿਉਕਿ ਇਸ ਨੂੰ ਹਮੇਸ਼ਾ ਲਈ ਚੱਲਦੀ ਹੈ ਅਜਿਹੇ ਇੱਕ ਪ੍ਰੋਗਰਾਮ, ਨੂੰ ਕੰਪਾਇਲ ਕਰਨ ਲਈ ਜਲਦਬਾਜ਼ੀ ਨਾ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ. ਸਾਨੂੰ ਅਜਿਹੇ ਹਾਲਾਤ ਹਨ ਕਿ ਕਦੇ ਝੂਠੇ ਮੁੱਲ ਹਾਲਤ «ਨੰਬਰ '<10 ਨੂੰ ਪੁੱਛਿਆ," ਇਸ ਕੇਸ ਵਿੱਚ ਅਤੇ ਹਮੇਸ਼ਾ ਸੱਚ ਹੈ, ਇਸ ਲਈ ਪੜਾਅ ਲਗਾਤਾਰ ਦੇ ਐਨ-ਫਰਬਰੀ ਨੂੰ ਨੰਬਰ ਲਿਆਉਣ ਹੋ ਜਾਵੇਗਾ "ਹੈਲੋ" ਸੁਨੇਹੇ. ਦਾ ਹੁਕਮ ਸਦੀਵੀ ਕੰਪਾਇਲ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਰੋਕਣ ਲਈ, ਤੁਹਾਨੂੰ ਸ਼ੈਲ ਵਿੱਚ ਸਵਿੱਚ ਮਿਸ਼ਰਨ Ctrl + C ਦੀ ਦਬਾਓ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ.

ਪਾਇਥਨ: ਸੰਟੈਕਸ. ਜਦਕਿ, ਅਤੇ ਇਹਨਆ ਲਈ

ਉਪਰੋਕਤ ਜ਼ਿਕਰ ਹੋਣ ਦੇ ਨਾਤੇ, "ਪਾਇਥਨ" ਪਰੋਗਰਾਮਿੰਗ ਦੀ ਭਾਸ਼ਾ ਵਿੱਚ, ਇੱਕ ਦੁਹਰਾਉ ਗਰੁੱਪ ਨੂੰ ਸਮੀਕਰਨ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਦੇ ਕਈ ਤਰੀਕੇ ਹਨ. ਇਹ ਬਚਾਅ ਕਰਨ ਲਈ ਆਇਆ ਹੈ ਲਈ ਲੂਪ, ਜੋ ਕਿ ਇਸ ਦੇ ਹਮਰੁਤਬਾ ਜਦਕਿ ਤੱਕ ਇੱਕ ਬਿੱਟ ਵੱਖ ਵੱਖ ਹੁੰਦਾ ਹੈ, ਕਿਉਕਿ ਇਸ ਦੇ ਡਿਜ਼ਾਇਨ ਨੂੰ ਸਿਰਫ਼ postcondition ਵੱਧ ਥੋੜਾ ਹੋਰ ਗੁੰਝਲਦਾਰ ਹੈ. ਦੀ, ਚੱਕਰ ਦੇ ਸਰਵ-ਬਾਰੇ ਗੱਲ ਨਾ ਹੈ, ਕਿਉਕਿ ਇਸ ਨੂੰ ਸਿਰਫ਼ ਨਾ, ਪਰ, ਨੋਟ ਕੀਤਾ ਜਾਣਾ ਹੈ ਕਿ ਲੂਪ ਲਈ ਇੱਕ ਜਦਕਿ ਵੱਧ ਬਹੁਤ ਤੇਜ਼ ਹੈ. ਤਰੀਕੇ ਦੀ ਇੱਕ ਕਿਸਮ ਦੇ ਡਿਜ਼ਾਇਨ ਅਤੇ postcondition ਨਾਲ ਇਸ ਛੋਟੇ ਕਾਇਮ ਚੱਕਰ ਦੇ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, ਇਸ ਲਈ ਇਸ ਨੂੰ ਹੋਰ ਬਹੁਤ ਕੁਝ ਨੂੰ ਬਹੁਤ ਮਾਮੂਲੀ ਕੰਮ ਕਰਨ ਵਾਸਤੇ ਵਰਤ ਕਰਨ ਦੀ ਸੰਭਾਵਨਾ ਹੈ.

ਚੁਣੌਤੀ ਲਈ ਚੱਕਰ ਦਾ ਸਾਹਮਣਾ ਕੀ ਹਨ? ਸ਼ੱਕ, ਜਦਕਿ ਦੀ ਹੈ, ਜੋ ਕਿ ਦੇ ਤੌਰ ਤੇ ਹੀ - ਕਿਸੇ ਵੀ ਕਾਰਜ iterate. ਪ੍ਰੋਗਰਾਮ "ਪਾਈਥਨ '' ਤੇ ਕੀਤੀ ਨੋਟ, ਵਿਆਪਕ ਲਈ ਲੂਪ, ਜੋ ਕਿ ਤੱਤ ਦੀ ਗੁਜ਼ਰਨ ਲਈ ਦਰਸਾਈ plurality ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੇ ਸਮਰੱਥ ਹੈ ਅਤੇ ਵੱਧ ਵੀ ਦੁਹਰਾਉਣਾ ਇਸ ਦੇ ਵੱਖ-ਵੱਖ ਸਰੀਰ ਵਿੱਚ ਕੰਮ ਕਰਨ ਲਈ ਵਰਤਿਆ ਗਿਆ ਹੈ. ਇਸ ਨੂੰ ਡਿਜ਼ਾਇਨ ਦੇ ਫੀਚਰ ਨੂੰ ਕਾਰਵਾਈ ਕਰਨ ਲਾਈਨ ਜ ਦੀ ਸੂਚੀ ਕਿਸੇ ਵੀ ਹੋਰ ਆਬਜੈਕਟ ਸਿਰਫ ਵਰਗੇ iterated ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ.

ਪਾਈਥਨ ਵਿੱਚ ਚੱਕਰ ਲਈ ਵਰਤਣ ਦੀ ਮਿਸਾਲ

ਦਾ ਕਹਿਣਾ ਹੈ ਕਿ ਸਾਨੂੰ ਗਿਣਤੀ ਦੇ ਕੁਝ ਸੂਚੀ ਵਿੱਚ ਹੈ, ਅਤੇ ਸਾਨੂੰ ਹਰ ਤੱਤ (ਭਾਵ. ਈ ਨੰਬਰ) ਨੂੰ ਤਿੰਨ ਯੂਨਿਟ ਦਾ ਵਾਧਾ ਲੋੜ ਹੈ. ਲੂਪ ਢੰਗ ਲਈ ਲੂਪ ਦੁਆਰਾ ਅਜਿਹੇ ਇੱਕ ਕੰਮ ਕਰ ਸਕਦੇ ਲਾਗੂ ਕਰਨ ਲਈ,.

ਦੀ ਇੱਕ ਤੇਜ਼ ਮਿਸਾਲ ਹੈ, ਜਿੱਥੇ ਸਾਨੂੰ (ਬਾਅਦ "#" ਅੱਖਰ ਇੱਕ ਟਿੱਪਣੀ ਹੈ) ਇਸ ਦੇ ਲਈ ਉਚਿਤ ਕਾਰਵਾਈ ਕਰਨ 'ਤੇ ਗੌਰ ਕਰੀਏ:

ਉਪਰੋਕਤ ਉਸਾਰੀ ਦਾ ਨਤੀਜਾ ਹੋਵੇਗਾ:

ਸਾਡੇ ਉਦਾਹਰਨ ਵਿੱਚ, ਉੱਥੇ ਇੱਕ ਵੇਰੀਏਬਲ ਗਿਣਤੀ ਹੈ, ਜੋ ਕਿ ਸਾਡੇ ਲਈ ਕ੍ਰਮ ਵਿੱਚ ਲੋੜ ਹੈ ਐਰੇ «spisok_chisel» ਵਿੱਚ ਬਦਲ ਰਹੀ ਮੁੱਲ ਨੂੰ ਮਨਾਉਣ ਲਈ ਹੈ. ਵੇਰੀਏਬਲ ਗਿਣਤੀ ਐਰੇ ਵਿੱਚ ਹਰ ਤੱਤ (ਸੂਚੀ ਵਿੱਚ ਹਰ ਨੰਬਰ) ਦੀ ਇਕ ਸੂਚਕ ਮੁੱਲ ਦਰਜ ਕੀਤਾ ਗਿਆ ਹੈ. ਅਸਥਿਰ «ਤੱਤ» ਸੂਚੀ ਵਿੱਚ ਨਤੀਜੇ ਮੁੱਲ ਜੁੜਦਾ ਹੈ. ਲੂਪ ਦੇ ਲਈ, ਸਾਨੂੰ ਦੱਸੋ ਅੰਕੀ ਸੂਚੀ ਵਿੱਚ ਹਰ ਇਕਾਈ ਦੀ ਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਵੇਖੋ. ਲੂਪ ਦੇ ਅੰਦਰ, ਇੰਡੈਕਸ «ਗਿਣਤੀ» ਦੇ ਨਾਲ, ਹਰ ਅੰਕ ਇਕਾਈ ਮੌਜੂਦਾ iterated ਤੱਤ ਅਤੇ ਤਿੰਨ ਦੀ ਮਾਤਰਾ ਹੈ. ਫਿਰ ਸਾਡੇ ਨਾਲ ਇੰਡੈਕਸ «ਦੀ ਗਿਣਤੀ» ਇੱਕ ਦਾ ਵਾਧਾ ਹੈ, ਅਤੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਲਾਗੂ ਕਰਨ ਦੇ ਵਹਾਅ ਲਈ ਉਸਾਰੀ ਵਿਗਿਆਪਨ ਦੀ ਸ਼ੁਰੂਆਤ ਕਰਨ ਲਈ ਵਾਪਸ. ਇਸ ਲਈ, ਲੂਪ, ਜਦ ਤੱਕ, ਜਦ ਤੱਕ ਇਸ ਨੂੰ ਐਰੇ ਵਿੱਚ ਹਰ ਤੱਤ, ਹਾਲਤ ਦੁਆਰਾ ਦਿੱਤਾ ਤੇ ਕਾਰਵਾਈ ਕੀਤੀ ਹੈ ਚਲਾਇਆ ਜਾਵੇਗਾ. ਕਿਸੇ ਵੀ ਤੱਤ ਗੁੰਮ ਹੈ, ਪਰ ਹਾਲਤ ਦੁਆਰਾ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ, ਜੇ, ਚੱਕਰ ਪੂਰਾ ਹੋ ਗਿਆ ਹੈ. ਸਾਨੂੰ ਇੱਕ ਹੋਰ ਗੱਲ ਵੱਲ ਧਿਆਨ ਖਿੱਚਣ: ਜੇਕਰ ਤੁਹਾਨੂੰ «ਗਿਣਤੀ ਦੀ ਇੱਕ ਲਾਈਨ = ਦੀ ਗਿਣਤੀ + 1", ਜੋ ਕਿ ਅਸਲ 'ਨੂੰ ਸਫਲਤਾਪੂਰਕ ਕਾਰਵਾਈ ਹੋ ਆਬਜੈਕਟ ਦੀ ਲੜੀ, ਇਸ ਦਾ ਨਤੀਜਾ ਹਮੇਸ਼ਾ ਪਹਿਲੇ ਅੰਕੀ ਇਕਾਈ ਦਾ ਸੂਚਕ ਜ਼ੀਰੋ ੲ ਨੂੰ ਸ਼ਾਮਿਲ ਕੀਤਾ ਜਾਵੇਗਾ ਦੇ ਬਾਵਜੂਦ ਲਿਖਣ ਦੀ ਨਾ ਕਰੋ.

ਹੁਣ ਸਾਨੂੰ, ਜਦਕਿ ਲੂਪ ਕਾਰਵਾਈ ਦੇ ਅਸੂਲ ਬਾਰੇ ਸੋਚਦੇ ਹਨ ਅਤੇ (ਦੇ postcondition ਨਾਲ ਚੱਕਰ ਲਾਜ਼ੀਕਲ ਮਾਪਦੰਡ ਦੇ ਆਧਾਰ 'ਤੇ ਬਾਹਰ ਹੀ ਰਿਹਾ ਹੈ ਨੂੰ ਬਾਹਰ ਯਾਦ ਹੈ ਕਿ ਪਾਇਥਨ ਵਿੱਚ - ਇਹ ਸੱਚ ਹੈ (ਚੱਕਰ ਜਾਰੀ ਹੈ) ਜ ਝੂਠੇ (ਚੱਕਰ ਰੁਕ)) ਫਰਕ ਦੀ ਪਛਾਣ ਕਰ ਸਕਦਾ ਹੈ.

ਕਰਨਾ ਪਾਇਥਨ ਵਿੱਚ ਇੱਕ ਸਤਰ ਲਈ ਡਿਜ਼ਾਇਨ ਵਰਤ ਦਾ ਇਲਾਜ ਕਰਨ ਲਈ?

ਹਰ ਪਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਵਿੱਚ ਚੱਕਰ ਹਨ, ਅਤੇ ਉਹ ਕੰਮ ਕਰਦੇ ਹਨ, ਆਮ ਤੌਰ 'ਤੇ ਉਸੇ ਹੀ ਅਸੂਲ' ਤੇ, ਅੰਤਰ ਸਿਰਫ ਖਾਕੇ ਵਿੱਚ ਦਿਸਦੀ. ਪਰ, ਭਾਸ਼ਾ "ਪਾਇਥਨ" ਵਿੱਚ ਲੂਪ ਲਈ ਹੈ, ਨਾ ਕਿ ਇੱਕ ਆਮ ਅਤੇ ਮਾਮੂਲੀ ਹੈ, ਕਿਉਕਿ ਇਸ ਦੇ ਕਾਰਵਾਈ ਦੇ ਅਸੂਲ ਵਿਰੋਧੀ ਤੱਕ ਹੀ ਸੀਮਿਤ ਨਹੀ ਹੈ, ਹੈ. ਇਹ ਡਿਜ਼ਾਇਨ ਹਰ ਇਕਾਈ ਨੂੰ ਵੱਖ ਵੱਖ ਕਰਦੀ ਹੈ. ਇਹ ਸਭ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਸਤਰ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਮਿਸਾਲ ਦੇ ਕੇ ਸਮਝਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ ਪਹਿਲੀ ਦੇ ਲਈ ਚੱਕਰ ਦੇ ਰਚਨਾ ਨਾਲ ਨਜਿੱਠਣ ਚਾਹੀਦਾ ਹੈ:

ਵੇਰੀਏਬਲ ਲਈ

ਇਹ ਇੱਕ ਵੇਰੀਏਬਲ ਚੱਕਰ ਕਾਰਵਾਈ ਦੇ ਨਤੀਜੇ ਵਿੱਚ ਸੰਭਾਲਿਆ ਗਿਆ ਹੈ

peremennaya_2 ਵਿਚ

«ਵਿਚ» ਕੁੰਜੀ ਸ਼ਬਦ ਨੂੰ - ਇਸ ਨੂੰ ਇੱਕ ਪੂਰਿ ਜਦ ਚੱਕਰ «ਲਈ» ਦੇ ਨਾਲ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ. peremennoy_2 ਤੋ ਸਾਨੂੰ ਮੁੱਲ ਹੈ, ਜੋ ਕਿ iterated ਕੀਤਾ ਜਾਵੇਗਾ ਕੱਢਣ. ਸਪੱਸ਼ਟ ਹੈ, ਅਤੇ ਸਪਸ਼ਟਤਾ ਲਈ, ਦੇ ਕੰਮ ਕਰਨ ਅਤੇ ਪਾਈਥਨ ਵਿੱਚ ਸਤਰ ਲੜੀਬੱਧ ਕਰਨ ਲਈ ਦੇ ਇੱਕ ਛੋਟੇ ਮਿਸਾਲ 'ਤੇ ਗੌਰ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ:

ਸਕਰਿਪਟ ਦਾ ਨਤੀਜਾ:

ਬਿਆਨ ਜਾਰੀ

ਆਪਰੇਟਰ ਅਗਲੇ ਚੱਕਰ ਦੇ ਲਾਗੂ ਕਰਨ ਲਈ ਤਬਦੀਲੀ, ਹਾਲਤ ਦੁਆਰਾ ਦਿੱਤਾ ਲਾਗੂ, ਲੂਪ ਦੇ ਸੰਤੁਲਨ ਦੀ ਪਰਵਾਹ ਜਾਰੀ. ਲਈ ਹੈ ਅਤੇ ਜਦਕਿ - ਜਾਰੀ ਬਿਆਨ ਦੋ ਚੱਕਰ ਵਿੱਚ ਹੋ ਸਕਦਾ ਹੈ ਵਰਤੋ.

ਇਸ ਮਿਸਾਲ 'ਤੇ ਗੌਰ:

ਇਸ ਦਾ ਨਤੀਜਾ ਹੇਠ ਹੋ ਜਾਵੇਗਾ:

ਜਦ ਹੈਡਲਰ ਪੱਤਰ "ਹੇ" ਸਤਰ ਵਿੱਚ ਲੱਭਿਆ ਦੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਲਾਗੂ ਨੂੰ ਤੁਰੰਤ ਸ਼ਬਦ '' ਜਾਰੀ ਰੱਖੋ '' ਹੈ, ਜਿੱਥੇ ਹਾਲਤ ਹਰ ਅੱਖਰ ਨੂੰ ਨਕਲ ਕਰਨ ਲਈ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ ਦੇ ਬਾਅਦ ਲਾਈਨ ਨੂੰ ਭੇਜੀ ਗਈ ਸੀ 'ਲਈ ਛੱਡ ਹਰ ਪੱਤਰ ਦੁਹਰਾ,'.

ਬ੍ਰੇਕ ਬਿਆਨ

ਕੀਵਰਡ «ਬ੍ਰੇਕ» ਜਿੱਥੇ ਜਗ੍ਹਾ ਚੱਕਰ ਪੂਰਾ ਹੈ, ਜੋ ਕਿ ਹਾਲਤ ਦੇ ਕੇ ਦਿੱਤਾ ਗਿਆ ਸੀ ਲਈ ਉਡੀਕ ਬਿਨਾ ਰੋਕਿਆ ਜਾ ਕਰਨ ਲਈ ਹੈ ਪਾਈ. ਇਹ ਡਿਜ਼ਾਇਨ ਅਕਸਰ ਵਰਤਿਆ ਹੈ ਜਦ ਤਰਕ ਹੈ ਅਤੇ ਹਾਲਾਤ ਦੀ ਇੱਕ ਬਹੁਤ ਸਾਰਾ ਦੇ ਨਾਲ ਪ੍ਰੋਗਰਾਮ ਲਿਖ ਰਹੀ ਹੈ.

ਕੰਮ ਦਾ ਬ੍ਰੇਕ ਬਿਆਨ ਦੇ ਇੱਕ ਛੋਟੇ ਮਿਸਾਲ 'ਤੇ ਗੌਰ ਕਰੋ:

ਇਸ ਦਾ ਨਤੀਜਾ ਹੇਠ ਹੋ ਜਾਵੇਗਾ:

ਜਦ ਹੈਡਲਰ ਪੱਤਰ "ਹੇ" ਸਤਰ ਵਿਚ ਪਾਇਆ ਹੈ ਕਿ ਇਸ ਤੱਥ ਨੂੰ ਅਗਲੇ ਲਾਈਨ ਚੱਕਰ ਲਈ ਹਾਲਾਤ ਦੇ ਕੁਝ ਸ਼ਾਮਿਲ ਹੈ ਦੇ ਬਾਵਜੂਦ ਪ੍ਰੋਗਰਾਮ ਦੇ ਚੱਲਣ ਨੂੰ ਤੁਰੰਤ ਰੋਕ ਦਿੱਤਾ ਗਿਆ ਸੀ, 'ਨੂੰ ਛੱਡ ਕੇ ਹਰ ਪੱਤਰ ਦੁਹਰਾ',.

ਹੋਰ ਜਾਦੂ ਸ਼ਬਦ ਨੂੰ

ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੀ ਇੱਕ ਲੜੀ ਵਿੱਚ ਹੋਰ ਆਪਰੇਟਰ ਅਰਜ਼ੀ ਦੇ ਸਕਦੇ ਹੋ. ਕੀ ਇਸ ਲਈ ਹੈ? ਉਸ ਨੇ ਇਹ ਵੀ ਚੈੱਕ ਕਰੋ ਕਿ ਲੂਪ ਦੇ ਬਾਹਰ ਵਚਨਬੱਧ ਗਿਆ ਸੀ ਇੱਕ ਬਰੇਕ ਜ ਆਮ ਤਰੀਕੇ ਨਾਲ ਮਤਲਬ ਹੈ. ਲਾਗੂ ਕਰਨ ਵਿੱਚ ਦਰਸਾਈ ਨਿਯਮ ਦੇ ਨਾਲ ਬਲਾਕ ਹੋਰ ਸ਼ੁਰੂ ਸਿਰਫ ਜਦ ਹਾਲਤ ਹੈ, ਜੋ ਕਿ ਚੱਕਰ ਦੀ ਆਉਟਪੁੱਟ ਬਰੇਕ ਬਣਤਰ ਦੀ ਵਰਤ ਦੇ ਬਗੈਰ ਬਾਹਰ ਹੀ ਕੀਤਾ ਗਿਆ ਸੀ.

ਇੱਕ ਛੋਟੇ ਮਿਸਾਲ 'ਤੇ ਗੌਰ ਕਰੋ:

ਸਕਰਿਪਟ ਦੀ ਆਊਟਪੁੱਟ:

ਪਾਇਥਨ ਪਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੇ ਉਲਟ ਕ੍ਰਮ ਵਿੱਚ ਚੱਕਰ ਦੇ ਉਦਾਹਰਣ

ਪਾਇਥਨ ਰਿਵਰਸ ਚੱਕਰ ਵਿੱਚ ਲਾਗੂ ਹੋਣ ਦੇ ਨਾਤੇ? ਦੀ ਕਲਪਨਾ ਕਰੋ, ਜੋ ਕਿ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਅੱਖਰ ਨੂੰ ਲਾਈਨ ਨੂੰ ਮਾਨਤਾ ਹੈ ਅਤੇ ਉਲਟਾ ਕ੍ਰਮ ਵਿੱਚ ਇਸ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ ਲੋੜ ਹੈ, ਜੋ ਕਿ ਲਿਖਣ ਕਰੀਏ. ਇਹ ਲਾਗੂ ਕਰਨ ਲਈ?

ਹੇਠ ਮਿਸਾਲ 'ਤੇ ਗੌਰ:

ਸਕਰਿਪਟ ਦਾ ਨਤੀਜਾ:

ਅੰਦਰੂਨੀ ਲੂਪਸ

ਪਾਇਥਨ ਵਿੱਚ, ਨੂੰ ਵੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਅਤੇ ਨਿਵੇਸ਼ ਹੈ, ਜੋ ਕਿ ਕਿਸੇ ਹੋਰ ਦੇ ਸਰੀਰ ਵਿੱਚ ਰੱਖਿਆ ਗਿਆ ਹੈ ਦੇ ਚੱਕਰ ਹਨ. ਹਰ ਚੱਕਰ ਵਿੱਚ ਇੱਕ ਅੰਦਰੂਨੀ ਲੂਪ ਹੋ ਸਕਦਾ ਹੈ, ਅਤੇ ਇਸ ਲਈ ਇਸ ਨੂੰ ਅਨੰਤ ਨੂੰ ਇੱਕ ਪੌੜੀ ਬਣਾਉਣ ਲਈ ਸੰਭਵ ਹੈ. ਬਾਹਰੀ ਲੂਪ ਦੇ ਪਹਿਲੇ ਪੜਾਅ 'ਚ ਅੰਦਰੂਨੀ ਲੂਪ, ਜੋ ਕਿ ਇਸ ਦੇ ਆਪਣੇ ਹੀ ਦੇ ਮੁਕੰਮਲ ਅੱਗੇ ਚੱਲਦੀ ਹੈ ਕਰਨ ਲਈ ਇੱਕ ਕਾਲ ਨਾਲ ਖਿੱਚਿਆ ਹੈ, ਫਿਰ ਸਾਰੇ ਬਾਹਰੀ ਚੱਕਰ ਦੇ ਸਰੀਰ ਵਿੱਚ ਨਿਰਦੇਸ਼ਤ ਨੂੰ ਕੰਟਰੋਲ. ਹਰ ਭਾਸ਼ਾ ਅੰਦਰੂਨੀ ਇਹਨਆ ਦੇ ਇਸ ਦੇ ਆਪਣੇ ਗੁਣ ਹਨ, ਦੀ ਉਹ "ਪਾਇਥਨ" ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਵਿੱਚ ਕੰਮ ਕਰਨ 'ਤੇ ਵੇਖੀਏ.

ਤੁਹਾਨੂੰ ਅੰਦਰੂਨੀ ਲੂਪਸ ਵਰਤ ਰਹੇ ਹੋ, ਪਾਇਥਨ ਹੇਠ ਸੰਟੈਕਸ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ:

ਅੰਦਰੂਨੀ ਇਹਨਆ ਦੇ ਖਾਸ ਫੀਚਰ, ਜੋ ਕਿ ਅਸਲ ਨੂੰ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੀ ਦੇ ਚੱਕਰ ਵਿੱਚ ਚੱਕਰ ਦੇ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੀ ਦੇ ਤੌਰ ਤੇ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਹੈ! ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇੱਕ ਚੱਕਰ ਵਿੱਚ ਹੈ, ਜਦਕਿ (ਜ ਲਈ) ਇੱਕ ਚੱਕਰ ਲਈ ਜ ਵਾਰ ਫਿਰ, ਜਦਕਿ ਅਤੇ ਉਲਟ ਸ਼ਾਮਿਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ.