ਪਾਈਥਨ ਵਿੱਚ ਲੂਪ ਲਈ

ਪਾਈਥਨ ਵਿੱਚ ਲੂਪ ਵਿੱਚ ਹੋਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਨਾਲੋਂ ਕੁਝ ਵੱਖਰੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹਨ। ਮੈਂ ਤੁਹਾਨੂੰ ਛੱਡਦਾ ਹਾਂ ਕਿ ਮੈਂ ਸਭ ਤੋਂ ਵੱਧ ਵਰਤੇ ਗਏ ਲੂਪਸ ਵਿੱਚੋਂ ਸਭ ਤੋਂ ਵੱਧ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਕੀ ਸਿੱਖ ਰਿਹਾ ਹਾਂ।

ਪਾਈਥਨ ਵਿੱਚ ਇਸਦਾ ਉਦੇਸ਼ ਇੱਕ ਦੁਹਰਾਉਣ ਯੋਗ ਵਸਤੂ ਦੁਆਰਾ ਦੁਹਰਾਉਣਾ ਹੈ, ਭਾਵੇਂ ਇਹ ਇੱਕ ਸੂਚੀ, ਇੱਕ ਵਸਤੂ, ਜਾਂ ਕੋਈ ਹੋਰ ਤੱਤ ਹੋਵੇ।

ਹੇਠ ਦਿੱਤੀ ਬਣਤਰ ਹੈ

h2=[ 'Valencia', 'Castellón', 'Alicante']

for j in h2:
   instructions

ਇੱਥੇ h2 ਇੱਕ ਦੁਹਰਾਇਆ ਜਾਣ ਵਾਲਾ ਤੱਤ ਹੈ ਉਦਾਹਰਨ ਲਈ ਇੱਕ ਸੂਚੀ h2=['ਵੈਲੈਂਸੀਆ', 'ਕੈਸਟੇਲਨ', 'ਐਲਿਕੈਂਟ']। ਲੂਪ ਵਿੱਚ 3 ਦੁਹਰਾਓ ਹੋਣਗੇ, ਪਹਿਲੇ ਵਿੱਚ j=Valencia ਦੂਜੇ ਵਿੱਚ ਵੇਰੀਏਬਲ j=Castellón।

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

ਲੂਪ ਲਈ ਇੱਕ ਸਹੀ ਸੰਖਿਆ ਵਾਰ ਦੁਹਰਾਓ।

ਜੇਕਰ ਅਸੀਂ ਚਾਹੁੰਦੇ ਹਾਂ ਕਿ ਇਹ ਇੱਕ ਨਿਸ਼ਚਿਤ ਗਿਣਤੀ ਨੂੰ ਦੁਹਰਾਇਆ ਜਾਵੇ ਜਿਵੇਂ ਕਿ ਅਸੀਂ C++ ਵਿੱਚ ਕਰ ਸਕਦੇ ਹਾਂ ਸਾਨੂੰ ਸੀਮਾ() ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਪਵੇਗੀ। 10 ਵਾਰ ਦੁਹਰਾਉਣ ਲਈ ਅਸੀਂ a ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ

for element in Range(9):
    instructions

ਅਸੀਂ 9 ਪਾਉਂਦੇ ਹਾਂ ਅਤੇ 10 ਨਹੀਂ ਕਿਉਂਕਿ ਰੇਂਜ 0 ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ, ਇਸ ਲਈ 0 ਤੋਂ 9 ਤੱਕ ਲੂਪ ਦੇ 10 ਦੁਹਰਾਓ ਜਾਂ ਮੋੜ ਹੁੰਦੇ ਹਨ।

Knowing Range() ਸਾਨੂੰ ਇੱਕ ਨੰਬਰ ਨੂੰ ਅੰਦਰ ਰੱਖਣ ਦੀ ਬਜਾਏ, ਇੱਕ ਵੇਰੀਏਬਲ ਰੱਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਇਸਲਈ ਸਾਡੇ ਕੋਲ ਬਹੁਤ ਜ਼ਿਆਦਾ ਨਿਯੰਤਰਣ ਹੋਵੇਗਾ।

var = 10
for element in Range(var):
    instructions

ਰੇਂਜ ਫੰਕਸ਼ਨ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਵਿਕਲਪ ਹਨ, ਮੈਂ ਇਸ ਬਾਰੇ ਕਿਸੇ ਹੋਰ ਪੋਸਟ ਵਿੱਚ ਗੱਲ ਕਰਾਂਗਾ, ਤਾਂ ਜੋ ਸਮੱਗਰੀ ਨੂੰ ਮਿਲਾਇਆ ਨਾ ਜਾਵੇ ਅਤੇ ਜਿੰਨਾ ਸੰਭਵ ਹੋ ਸਕੇ ਇਸ ਨੂੰ ਵਿਕਸਤ ਕੀਤਾ ਜਾਵੇ.

ਫਾਰ ਲੂਪ ਦੇ ਪ੍ਰਵਾਹ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਹੋਰ ਬਹੁਤ ਕੁਝ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਬਿਆਨਾਂ ਨੂੰ ਤੋੜੋ ਅਤੇ ਜਾਰੀ ਰੱਖੋ

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

ਉਹ ਹੋਰ ਲੂਪਸ ਵਿੱਚ ਕੰਮ ਕਰਦੇ ਹਨ, ਅਤੇ ਇੱਕ ਹੋਰ ਦਿਲਚਸਪ ਕਥਨ ਹੈ ਜੋ ਪਾਸ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਬਿਆਨ ਹੈ ਜੋ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਪਰ ਕੁਝ ਨਹੀਂ ਕਰਦਾ ਅਤੇ ਉਸ ਲਈ ਆਦਰਸ਼ ਹੈ ਜਦੋਂ ਅਸੀਂ ਇੱਕ ਢਾਂਚੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ ਜਿਸ ਲਈ ਕਮਾਂਡਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਪਰ ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਬਾਅਦ ਵਿੱਚ ਰੱਖਣਾ ਚਾਹੁੰਦੇ ਹਾਂ (ਟਿੱਪਣੀਆਂ ਹਨ ਇਸ ਲਈ ਲਾਭਦਾਇਕ ਨਹੀਂ ਹੈ)

ਬਰੇਕ

ਬਰੇਕ ਨਾਲ ਅਸੀਂ ਕਿਸੇ ਵੀ ਸਮੇਂ ਲੂਪ ਤੋਂ ਬਾਹਰ ਆ ਸਕਦੇ ਹਾਂ। ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਬਹੁਤ ਉਪਯੋਗੀ ਕਲਪਨਾ ਕਰਦੇ ਹੋ. ਇਹ ਸੱਚ ਹੈ ਕਿ ਇੱਥੇ ਹੋਰ ਢਾਂਚੇ ਵੀ ਹਨ ਜਿਵੇਂ ਕਿ,

numeros = [1, 2, 4, 3, 5, 8, 6]
for n in numeros:
    if n == 3:
        break
else:
    print('No se encontró el número 3')

ਜਾਰੀ ਰੱਖੋ

ਇਹ ਸਾਨੂੰ ਲੂਪ ਵਿੱਚ ਅਗਲੇ ਐਲੀਮੈਂਟ ਤੇ ਜਾਣ ਲਈ ਬਣਾਉਂਦਾ ਹੈ।

numeros = [1, 2, 4, 3, 5, 8, 6]
for n in numeros:
    if n == 3:
        continue
else:
    print('No se encontró el número 3')

https://j2logo.com/bucle-for-en-python/

ਲਈ … ਹੋਰ

For ਤੋਂ ਲਿਆ ਗਿਆ ਇੱਕ ਢਾਂਚਾ ਹੈ, ਜੋ ਕਿ … else ਲਈ ਹੈ

datos = [1, 2, 3, 4, 5]
for n in datos:
    if n == 2:
        break
else:
    print('No hay 2')

ਇਹ ਢਾਂਚਾ ਉਦੋਂ ਪੈਦਾ ਹੋਇਆ ਜਦੋਂ ਉਨ੍ਹਾਂ ਨੇ ਦੇਖਿਆ ਕਿ ਇਹ ਜ਼ਰੂਰੀ ਸੀ ਅਤੇ ਬਹੁਤ ਸਾਰੇ ਲੋਕ ਇਸ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਵਿਕਲਪਕ ਤਰੀਕੇ ਵਰਤ ਰਹੇ ਸਨ। ਇਸ ਤਰ੍ਹਾਂ, ਉਹ ਲੋਕਾਂ ਦੀ ਮਦਦ ਕਰਦੇ ਹਨ ਅਤੇ ਵਧੇਰੇ ਪੜ੍ਹਨਯੋਗ ਕੋਡ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਨ

ਦੁਹਰਾਉਣਯੋਗ ਵਿੱਚ _ ਲਈ

ਮੈਂ ਇਸਨੂੰ ਕੁਝ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਦੇਖਿਆ ਹੈ ਹਾਲਾਂਕਿ ਮੈਂ ਇਸਨੂੰ ਕਦੇ ਨਹੀਂ ਵਰਤਿਆ ਹੈ।

ਜਦੋਂ ਅਸੀਂ ਕਿਸੇ ਵਸਤੂ, ਸੂਚੀ, ਸ਼ਬਦਕੋਸ਼, ਆਦਿ ਨੂੰ ਦੁਹਰਾਉਂਦੇ ਹਾਂ, ਪਰ ਉਹਨਾਂ ਤੱਤਾਂ ਦੀ ਸਮੱਗਰੀ ਸਾਡੀ ਦਿਲਚਸਪੀ ਨਹੀਂ ਰੱਖਦੀ, ਅਸੀਂ ਇਸਨੂੰ _ ਨਾਲ ਦਰਸਾ ਸਕਦੇ ਹਾਂ

ਇੱਕ ਉਦਾਹਰਣ:

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

h2=[ 'Valencia', 'Castellón', 'Alicante']
count = 0
for _ in h2:
    cont += 1

ਬਹੁਤ ਸਾਰੀਆਂ ਸਾਈਟਾਂ ਵਿੱਚ ਉਹ ਇਸ ਅਭਿਆਸ ਦੀ ਦੁਰਵਰਤੋਂ ਨਾ ਕਰਨ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦੇ ਹਨ। ਮੈਨੂੰ ਸੱਚਮੁੱਚ ਨਹੀਂ ਪਤਾ ਕਿ ਇਹ ਕਿਹੜੇ ਫਾਇਦੇ ਪੇਸ਼ ਕਰਦਾ ਹੈ, ਕੀ ਇਹ ਤੇਜ਼ ਹੈ?

Lo recomiendan en el curso de Introducción a Python de Harvard. Cuando iteramos sobre una variable pero no vamos a usrarla para nada ponemos el undescore, es como comentan allí un Pythonic, una práctica de Python que no se ve en otros idiomas, ayuda a la legibilidad por no tener que estar pendiente de para qué sirve.

ਪਿੱਛੇ ਵੱਲ ਲੂਪਿੰਗ

ਲੂਪ ਲਈ ਪਿੱਛੇ. ਅੰਤ ਤੋਂ ਸ਼ੁਰੂ ਤੱਕ ਦੁਹਰਾਉਣ ਲਈ

ਇਹ python 3 ਵਿੱਚ ਪੇਸ਼ ਕੀਤੇ reversed() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ

h2=[ 'Valencia', 'Castellón', 'Alicante']

for j in reversed(h2):
    print (j)

ਦੋ ਸੂਚਕਾਂਕ ਦੇ ਨਾਲ ਲੂਪਿੰਗ, ਦੁਹਰਾਉਣਯੋਗ ਅਤੇ ਸੂਚਕਾਂਕ ਦਾ ਮੁੱਲ

enumerate() ਨਾਲ ਅਸੀਂ ਕਲੈਕਸ਼ਨ ਦੇ ਸੂਚਕਾਂਕ ਨਾਲ ਕੰਮ ਕਰ ਸਕਦੇ ਹਾਂ। ਕਿਉਂਕਿ ਕਈ ਵਾਰ, ਦੁਹਰਾਉਣ ਯੋਗ ਵਸਤੂ ਦੇ ਮੁੱਲ ਤੋਂ ਇਲਾਵਾ, ਅਸੀਂ ਇਸਦੇ ਸੂਚਕਾਂਕ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹਾਂ।

h2=[ 'Valencia', 'Castellón', 'Alicante']

for j, h in enumerate(h2):
    print j, '-->', h2[i] 

2 ਤੋਂ ਵੱਧ ਸੂਚੀਆਂ ਨੂੰ ਦੁਹਰਾਉਣਾ

ਇੱਕ ਹੋਰ ਬਹੁਤ ਹੀ ਦਿਲਚਸਪ ਵਿਕਲਪ ਹੈ zip() ਜੋ ਸਾਡੇ ਕੰਮ ਨੂੰ ਆਸਾਨ ਬਣਾਵੇਗਾ ਅਤੇ ਸਾਡੇ ਕੋਡ ਨੂੰ ਸਰਲ ਅਤੇ ਹੋਰ ਪੜ੍ਹਨਯੋਗ ਬਣਾਏਗਾ।

h2=[ 'Valencia', 'Castellón', 'Alicante']
cod=[100, 200, 300]

for j, h in zip(h2, cod):
    print h2, '-->', cod 

ਪਾਈਥਨ 2.x ਵਿੱਚ izip() ਦੀ ਵਰਤੋਂ ਇਸ ਫੰਕਸ਼ਨ ਨੂੰ ਵਧਾਉਣ ਲਈ ਕੀਤੀ ਗਈ ਸੀ, ਪਰ ਪਾਈਥਨ 3 ਵਿੱਚ izip zip() ਹੈ।

ਕ੍ਰਮਬੱਧ ਕ੍ਰਮ ਵਿੱਚ ਲੂਪਿੰਗ

ਵਸਤੂ ਦੇ ਸੂਚਕਾਂਕ ਦੀ ਬਜਾਏ ਇਸਦੇ ਮੁੱਲ ਦੁਆਰਾ ਕ੍ਰਮ ਵਿੱਚ ਦੁਹਰਾਓ। sorted() ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ

colors = ['rojo', 'amarillo', 'verde']

for color in sorted(colors):
    print color

ਅਤੇ ਜੇਕਰ ਅਸੀਂ ਇਸਨੂੰ ਪਿੱਛੇ ਵੱਲ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ

colors = ['rojo', 'amarillo', 'verde']

for color in sorted(colors, reverse=True):
    print color

ਕਸਟਮ ਲੜੀਬੱਧ ਆਰਡਰ

colors = ['rojo', 'amarillo', 'verde']

for color in sorted(colors, key=len):
    print color

ਲੂਪ ਲਈ ਸੈਂਟੀਨੇਲ ਮੁੱਲ

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

blocks = []
for block in iter(partial(f.read, 32), ''):
    blocks.append(block)
    print (block)

ਲਈ ਦੇ ਨਾਲ ਸ਼ਬਦਕੋਸ਼ ਨੂੰ ਪਾਰ ਕਰੋ

ਸ਼ਬਦਕੋਸ਼ ਸਬੰਧਾਂ ਨੂੰ ਪ੍ਰਗਟ ਕਰਨ ਅਤੇ ਸਮੂਹ ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਸਾਧਨ ਹਨ।

ਤੁਸੀਂ for ਦੇ ਨਾਲ ਇੱਕ ਰਵਾਇਤੀ ਤਰੀਕੇ ਨਾਲ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਜਾ ਸਕਦੇ ਹੋ, ਪਰ ਇਹ ਸਾਰੀ ਜਾਣਕਾਰੀ ਵਾਪਸ ਨਹੀਂ ਕਰੇਗਾ, ਅਸੀਂ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਮੁੱਲਾਂ ਅਤੇ ਸੂਚਕਾਂਕ ਨਾਲ ਕੰਮ ਨਹੀਂ ਕਰ ਸਕਾਂਗੇ, ਜੇਕਰ ਅਸੀਂ ਕਾਊਂਟਰਾਂ ਅਤੇ ਹੋਰ ਤੱਤਾਂ ਨੂੰ ਜੋੜਨਾ ਸ਼ੁਰੂ ਨਹੀਂ ਕਰਦੇ ਹਾਂ।

d = {'casa': 'azul', 'coche': 'rojo', 'hombre': 'verde'}

for k in d.keys():
    if k.startswith('r'):
        del d[k]

ਇਸ ਤਰ੍ਹਾਂ, ਐਲੀਮੈਂਟਸ ਨੂੰ ਦੇਖਣ ਤੋਂ ਇਲਾਵਾ, ਅਸੀਂ ਐਲੀਮੈਂਟਸ ਨੂੰ ਬਦਲ ਕੇ ਜਾਂ ਡਿਲੀਟ ਕਰਕੇ ਡਿਕਸ਼ਨਰੀ ਨੂੰ ਸੋਧ ਸਕਦੇ ਹਾਂ, ਉਸੇ ਸਮੇਂ ਜਦੋਂ ਲੂਪ ਨੂੰ ਦੁਹਰਾਇਆ ਜਾਂਦਾ ਹੈ।

d.keys() ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ ਅਤੇ ਇੱਕ ਕਾਪੀ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਇਹ ਇੱਕ ਸੂਚੀ ਵਿੱਚ ਸਟੋਰ ਕਰਦਾ ਹੈ ਜਿਸ ਨੂੰ ਅਸੀਂ ਸੋਧ ਸਕਦੇ ਹਾਂ।

ਪਰੰਪਰਾਗਤ ਚੀਜ਼ ਦੀ ਬਜਾਏ ਸੂਚਕਾਂਕ ਅਤੇ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਅਤੇ ਇਹ ਪਹਿਲੀ ਚੀਜ਼ ਹੈ ਜੋ ਸਾਡੇ ਵਿੱਚੋਂ ਉਹਨਾਂ ਲਈ ਮਨ ਵਿੱਚ ਆਉਂਦੀ ਹੈ ਜੋ ਪ੍ਰੋਗਰਾਮਿੰਗ ਸ਼ੁਰੂ ਕਰਦੇ ਹਨ

for k in d:
    print k, '-->', d[k]

ਅਸੀਂ ਇਸ ਨੂੰ ਬਹੁਤ ਤੇਜ਼ ਵਿਕਲਪ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ

for k, v in d.items():
    print k, '-->', v

ਆਈਟਮਾਂ () ਨਾਲੋਂ ਦੁਹਰਾਓ ()

ਰੇਮੰਡ ਹੈਟਿੰਗਰ ਦੁਆਰਾ ਪਾਈਥਨ ਵਿੱਚ ਲੂਪਸ ਬਾਰੇ ਗੱਲ ਕਰੋ

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