6. ਮੌਡਿਊਲ

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

ਇਸ ਦਾ ਸਮਰਥਨ ਕਰਨ ਲਈ, ਪਾਇਥਨ ਵਿੱਚ ਪਰਿਭਾਸ਼ਾਵਾਂ ਨੂੰ ਇੱਕ ਫਾਇਲ ਵਿੱਚ ਰੱਖਣ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸਕ੍ਰਿਪਟ ਜਾਂ ਇੰਟਰਪ੍ਰੀਟਰ ਦੇ ਇੰਟਰਐਕਟਿਵ ਸੈਸ਼ਨ ਵਿੱਚ ਵਰਤਣ ਦਾ ਤਰੀਕਾ ਹੈ। ਅਜਿਹੀ ਫਾਇਲ ਨੂੰ ਮੌਡਿਊਲ ਕਿਹਾ ਜਾਂਦਾ ਹੈ; ਇੱਕ ਮੌਡਿਊਲ ਦੀਆਂ ਪਰਿਭਾਸ਼ਾਵਾਂ ਨੂੰ ਹੋਰ ਮੌਡਿਊਲਾਂ ਜਾਂ ਮੁੱਖ ਮੌਡਿਊਲ ਵਿੱਚ import ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ (ਅਰਥਾਤ ਉਹਨਾਂ ਚਲਾਂ ਦਾ ਸਮੂਹ ਜਿਨ੍ਹਾਂ ਤੱਕ ਤੁਹਾਡੀ ਪਹੁੰਚ ਉੱਚ ਪੱਧਰ 'ਤੇ ਚੱਲ ਰਹੀ ਸਕ੍ਰਿਪਟ ਅਤੇ ਕੈਲਕੂਲੇਟਰ ਮੋਡ ਵਿੱਚ ਹੁੰਦੀ ਹੈ)।

ਮੌਡਿਊਲ ਇੱਕ ਫਾਇਲ ਹੁੰਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਪਾਇਥਨ ਦੀਆਂ ਪਰਿਭਾਸ਼ਾਵਾਂ ਅਤੇ ਕਥਨ ਹੁੰਦੇ ਹਨ। ਫਾਇਲ ਦਾ ਨਾਮ ਮੌਡਿਊਲ ਦੇ ਨਾਮ ਨਾਲ .py ਪ੍ਰਤਯ ਜੋੜ ਕੇ ਬਣਦਾ ਹੈ। ਮੌਡਿਊਲ ਦੇ ਅੰਦਰ, ਮੌਡਿਊਲ ਦਾ ਨਾਮ (ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ) ਗਲੋਬਲ ਚਲ __name__ ਦੇ ਮੁੱਲ ਵਜੋਂ ਉਪਲਬਧ ਹੁੰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਆਪਣੇ ਮਨਪਸੰਦ ਟੈਕਸਟ ਐਡੀਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੌਜੂਦਾ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ fibo.py ਨਾਮ ਦੀ ਫਾਇਲ ਬਣਾਓ ਜਿਸਦਾ ਸਮੱਗਰੀ ਹੇਠਾਂ ਦਿੱਤੀ ਗਈ ਹੈ:

# Fibonacci numbers module

def fib(n):
    """Write Fibonacci series up to n."""
    a, b = 0, 1
    while a < n:
        print(a, end=' ')
        a, b = b, a+b
    print()

def fib2(n):
    """Return Fibonacci series up to n."""
    result = []
    a, b = 0, 1
    while a < n:
        result.append(a)
        a, b = b, a+b
    return result

ਹੁਣ ਪਾਇਥਨ ਇੰਟਰਪ੍ਰੀਟਰ ਵਿੱਚ ਜਾਓ ਅਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਕਮਾਂਡ ਨਾਲ ਇਸ ਮੌਡਿਊਲ ਨੂੰ import ਕਰੋ:

>>> import fibo

ਇਹ fibo ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਫੰਕਸ਼ਨਾਂ ਦੇ ਨਾਮ ਸਿੱਧੇ ਮੌਜੂਦਾ namespace ਵਿੱਚ ਨਹੀਂ ਜੋੜਦਾ (ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਲਈ Python ਵਿੱਚ ਸਕੋਪ ਅਤੇ ਨੇਮਸਪੇਸ ਵੇਖੋ); ਇਹ ਸਿਰਫ਼ ਮੌਡਿਊਲ ਦਾ ਨਾਮ fibo ਉੱਥੇ ਜੋੜਦਾ ਹੈ। ਮੌਡਿਊਲ ਦੇ ਨਾਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤੁਸੀਂ ਫੰਕਸ਼ਨਾਂ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦੇ ਹੋ:

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'

ਜੇ ਤੁਸੀਂ ਕਿਸੇ ਫੰਕਸ਼ਨ ਨੂੰ ਬਾਰ-ਬਾਰ ਵਰਤਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇਸਨੂੰ ਕਿਸੇ ਸਥਾਨਕ ਨਾਮ ਨਾਲ ਜੋੜ ਸਕਦੇ ਹੋ:

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

6.1. ਮੌਡਿਊਲਾਂ ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ

ਮੌਡਿਊਲ ਵਿੱਚ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਾਵਾਂ ਦੇ ਨਾਲ-ਨਾਲ ਚੱਲਣਯੋਗ ਕਥਨ ਵੀ ਹੋ ਸਕਦੇ ਹਨ। ਇਹ ਕਥਨ ਮੌਡਿਊਲ ਨੂੰ ਸ਼ੁਰੂਆਤੀ ਹਾਲਤ ਵਿੱਚ ਲਿਆਉਣ ਲਈ ਹੁੰਦੇ ਹਨ। ਇਹ ਸਿਰਫ਼ ਪਹਿਲੀ ਵਾਰ ਚਲਾਏ ਜਾਂਦੇ ਹਨ ਜਦੋਂ ਮੌਡਿਊਲ ਦਾ ਨਾਮ ਕਿਸੇ import ਕਥਨ ਵਿੱਚ ਮਿਲਦਾ ਹੈ। [1] (ਜੇ ਫਾਇਲ ਨੂੰ ਸਕ੍ਰਿਪਟ ਵਜੋਂ ਚਲਾਇਆ ਜਾਵੇ ਤਾਂ ਇਹ ਵੀ ਚਲਦੇ ਹਨ।)

ਹਰ ਮੌਡਿਊਲ ਦਾ ਆਪਣਾ ਨਿੱਜੀ namespace ਹੁੰਦਾ ਹੈ, ਜੋ ਮੌਡਿਊਲ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਲਈ global namespace ਵਜੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ, ਮੌਡਿਊਲ ਦਾ ਲੇਖਕ ਮੌਡਿਊਲ ਦੇ global variables ਵਰਤ ਸਕਦਾ ਹੈ ਬਿਨਾਂ ਇਸ ਚਿੰਤਾ ਦੇ ਕਿ ਉਹ ਵਰਤੋਂਕਾਰ ਦੇ global variables ਨਾਲ ਟਕਰਾ ਜਾਣਗੇ। ਦੂਜੇ ਪਾਸੇ, ਜੇ ਤੁਹਾਨੂੰ ਪਤਾ ਹੈ ਕਿ ਤੁਸੀਂ ਕੀ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ modname.itemname ਨੋਟੇਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੌਡਿਊਲ ਦੇ global variables ਤੱਕ ਵੀ ਪਹੁੰਚ ਕਰ ਸਕਦੇ ਹੋ।

ਮੌਡਿਊਲ ਹੋਰ ਮੌਡਿਊਲਾਂ ਨੂੰ import ਕਰ ਸਕਦੇ ਹਨ। ਆਮ ਤੌਰ 'ਤੇ ਸਾਰੇ import ਕਥਨ ਮੌਡਿਊਲ (ਜਾਂ ਸਕ੍ਰਿਪਟ) ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਲਿਖੇ ਜਾਂਦੇ ਹਨ, ਹਾਲਾਂਕਿ ਇਹ ਲਾਜ਼ਮੀ ਨਹੀਂ ਹੈ। ਜੇ import ਕੀਤੇ ਮੌਡਿਊਲਾਂ ਦੇ ਨਾਮ ਮੌਡਿਊਲ ਦੇ ਉੱਚ ਪੱਧਰ 'ਤੇ (ਕਿਸੇ ਫੰਕਸ਼ਨ ਜਾਂ ਕਲਾਸ ਦੇ ਬਾਹਰ) ਲਿਖੇ ਜਾਣ, ਤਾਂ ਉਹ ਮੌਡਿਊਲ ਦੇ global namespace ਵਿੱਚ ਸ਼ਾਮਲ ਹੋ ਜਾਂਦੇ ਹਨ।

import ਕਥਨ ਦਾ ਇੱਕ ਰੂਪ ਅਜਿਹਾ ਵੀ ਹੈ ਜੋ ਕਿਸੇ ਮੌਡਿਊਲ ਤੋਂ ਨਾਮਾਂ ਨੂੰ ਸਿੱਧੇ import ਕਰਨ ਵਾਲੇ ਮੌਡਿਊਲ ਦੇ namespace ਵਿੱਚ ਲਿਆਉਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ:

>>> from fibo import fib, fib2
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

ਇਹ ਉਸ ਮੌਡਿਊਲ ਦਾ ਨਾਮ local namespace ਵਿੱਚ ਨਹੀਂ ਲਿਆਉਂਦਾ ਜਿਸ ਤੋਂ import ਕੀਤਾ ਗਿਆ ਹੈ (ਇਸ ਲਈ ਉਦਾਹਰਨ ਵਿੱਚ fibo ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਹੈ)।

ਮੌਡਿਊਲ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਸਾਰੇ ਨਾਮ import ਕਰਨ ਲਈ ਵੀ ਇੱਕ ਰੂਪ ਮੌਜੂਦ ਹੈ:

>>> from fibo import *
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

ਇਹ underscore (_) ਨਾਲ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲੇ ਨਾਮਾਂ ਤੋਂ ਇਲਾਵਾ ਸਾਰੇ ਨਾਮ import ਕਰਦਾ ਹੈ। ਜ਼ਿਆਦਾਤਰ ਮਾਮਲਿਆਂ ਵਿੱਚ Python ਪ੍ਰੋਗਰਾਮਰ ਇਸ ਤਰੀਕੇ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਦੇ, ਕਿਉਂਕਿ ਇਹ ਇੰਟਰਪ੍ਰੀਟਰ ਵਿੱਚ ਅਣਜਾਣ ਨਾਮਾਂ ਦਾ ਸਮੂਹ ਸ਼ਾਮਲ ਕਰ ਦਿੰਦਾ ਹੈ, ਜੋ ਤੁਹਾਡੇ ਪਹਿਲਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੇ ਕੁਝ ਨਾਮਾਂ ਨੂੰ ਲੁਕਾ ਸਕਦਾ ਹੈ।

ਧਿਆਨ ਦਿਓ ਕਿ ਆਮ ਤੌਰ 'ਤੇ ਕਿਸੇ ਮੌਡਿਊਲ ਜਾਂ ਪੈਕੇਜ ਤੋਂ * import ਕਰਨਾ ਚੰਗਾ ਅਭਿਆਸ ਨਹੀਂ ਮੰਨਿਆ ਜਾਂਦਾ, ਕਿਉਂਕਿ ਇਸ ਨਾਲ ਕੋਡ ਘੱਟ ਪੜ੍ਹਨਯੋਗ ਬਣ ਜਾਂਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਇੰਟਰਐਕਟਿਵ ਸੈਸ਼ਨਾਂ ਵਿੱਚ ਟਾਈਪਿੰਗ ਘਟਾਉਣ ਲਈ ਇਸਦੀ ਵਰਤੋਂ ਕਰਨਾ ਠੀਕ ਹੈ।

ਜੇ ਮੌਡਿਊਲ ਦੇ ਨਾਮ ਤੋਂ ਬਾਅਦ as ਲਿਖਿਆ ਹੋਵੇ, ਤਾਂ as ਤੋਂ ਬਾਅਦ ਦਿੱਤਾ ਗਿਆ ਨਾਮ ਸਿੱਧੇ import ਕੀਤੇ ਮੌਡਿਊਲ ਨਾਲ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ।

>>> import fibo as fib
>>> fib.fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

ਇਹ ਮੌਡਿਊਲ ਨੂੰ ਉਸੇ ਤਰੀਕੇ ਨਾਲ import ਕਰਦਾ ਹੈ ਜਿਵੇਂ import fibo ਕਰਦਾ ਹੈ, ਫ਼ਰਕ ਸਿਰਫ਼ ਇਹ ਹੈ ਕਿ ਇਹ fib ਨਾਮ ਨਾਲ ਉਪਲਬਧ ਹੁੰਦਾ ਹੈ।

ਇਸੇ ਤਰ੍ਹਾਂ ਦਾ ਪ੍ਰਭਾਵ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸਨੂੰ from ਨਾਲ ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ:

>>> from fibo import fib as fibonacci
>>> fibonacci(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Note

ਕਾਰਗੁਜ਼ਾਰੀ ਦੇ ਕਾਰਨਾਂ ਕਰਕੇ, ਹਰ ਮੌਡਿਊਲ ਨੂੰ ਇੱਕ ਇੰਟਰਪ੍ਰੀਟਰ ਸੈਸ਼ਨ ਵਿੱਚ ਕੇਵਲ ਇੱਕ ਵਾਰ ਹੀ import ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਸ ਲਈ, ਜੇ ਤੁਸੀਂ ਆਪਣੇ ਮੌਡਿਊਲਾਂ ਵਿੱਚ ਤਬਦੀਲੀ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਇੰਟਰਪ੍ਰੀਟਰ ਨੂੰ ਦੁਬਾਰਾ ਸ਼ੁਰੂ ਕਰਨਾ ਪਵੇਗਾ — ਜਾਂ ਜੇ ਤੁਸੀਂ ਸਿਰਫ਼ ਇੱਕ ਮੌਡਿਊਲ ਨੂੰ ਇੰਟਰਐਕਟਿਵ ਤਰੀਕੇ ਨਾਲ ਜਾਂਚਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ importlib.reload() ਵਰਤੋ, ਉਦਾਹਰਨ ਲਈ import importlib; importlib.reload(modulename)।

6.1.1. ਮੌਡਿਊਲਾਂ ਨੂੰ ਸਕ੍ਰਿਪਟ ਵਜੋਂ ਚਲਾਉਣਾ

ਜਦੋਂ ਤੁਸੀਂ ਕਿਸੇ Python ਮੌਡਿਊਲ ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਤਰੀਕੇ ਨਾਲ ਚਲਾਉਂਦੇ ਹੋ:

python fibo.py <arguments>

ਮੌਡਿਊਲ ਦੇ ਅੰਦਰਲਾ ਕੋਡ ਠੀਕ ਉਸੇ ਤਰ੍ਹਾਂ ਚਲਾਇਆ ਜਾਵੇਗਾ ਜਿਵੇਂ ਇਸਨੂੰ import ਕੀਤਾ ਗਿਆ ਹੋਵੇ, ਪਰ __name__ ਦਾ ਮੁੱਲ "__main__" ਹੋਵੇਗਾ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਆਪਣੇ ਮੌਡਿਊਲ ਦੇ ਅੰਤ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤਾ ਕੋਡ ਜੋੜ ਕੇ:

if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))

ਤੁਸੀਂ ਫਾਇਲ ਨੂੰ ਸਕ੍ਰਿਪਟ ਵਜੋਂ ਵੀ ਅਤੇ import ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਮੌਡਿਊਲ ਵਜੋਂ ਵੀ ਵਰਤਣਯੋਗ ਬਣਾ ਸਕਦੇ ਹੋ, ਕਿਉਂਕਿ ਕਮਾਂਡ ਲਾਈਨ ਨੂੰ ਪਾਰਸ ਕਰਨ ਵਾਲਾ ਕੋਡ ਸਿਰਫ਼ ਉਸ ਵੇਲੇ ਚਲਦਾ ਹੈ ਜਦੋਂ ਮੌਡਿਊਲ ਨੂੰ "main" ਫਾਇਲ ਵਜੋਂ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ:

$ python fibo.py 50
0 1 1 2 3 5 8 13 21 34

ਜੇ ਮੌਡਿਊਲ ਨੂੰ import ਕੀਤਾ ਜਾਵੇ, ਤਾਂ ਇਹ ਕੋਡ ਨਹੀਂ ਚਲਦਾ:

>>> import fibo
>>>

ਇਸਦੀ ਵਰਤੋਂ ਅਕਸਰ ਮੌਡਿਊਲ ਲਈ ਇੱਕ ਸੁਵਿਧਾਜਨਕ ਯੂਜ਼ਰ ਇੰਟਰਫੇਸ ਮੁਹੱਈਆ ਕਰਵਾਉਣ ਜਾਂ ਟੈਸਟਿੰਗ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ (ਮੌਡਿਊਲ ਨੂੰ ਸਕ੍ਰਿਪਟ ਵਜੋਂ ਚਲਾਉਣ ਨਾਲ ਟੈਸਟ ਸੂਟ ਚਲਦਾ ਹੈ)।

6.1.2. ਮੌਡਿਊਲ ਖੋਜ ਮਾਰਗ

ਜਦੋਂ spam ਨਾਮ ਦਾ ਕੋਈ ਮੌਡਿਊਲ import ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇੰਟਰਪ੍ਰੀਟਰ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਉਸ ਨਾਮ ਵਾਲੇ built-in ਮੌਡਿਊਲ ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ। ਇਨ੍ਹਾਂ ਮੌਡਿਊਲਾਂ ਦੇ ਨਾਮ sys.builtin_module_names ਵਿੱਚ ਦਿੱਤੇ ਹੁੰਦੇ ਹਨ। ਜੇਕਰ ਉਹ ਨਾ ਮਿਲੇ, ਤਾਂ ਇਹ sys.path ਚਲ ਦੁਆਰਾ ਦਿੱਤੀਆਂ ਡਾਇਰੈਕਟਰੀਆਂ ਦੀ ਸੂਚੀ ਵਿੱਚ spam.py ਨਾਮ ਦੀ ਫਾਇਲ ਲੱਭਦਾ ਹੈ। sys.path ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਸਥਾਨਾਂ ਤੋਂ ਸ਼ੁਰੂਆਤੀ ਮੁੱਲ ਮਿਲਦਾ ਹੈ:

• ਉਹ ਡਾਇਰੈਕਟਰੀ ਜਿਸ ਵਿੱਚ ਇਨਪੁੱਟ ਸਕ੍ਰਿਪਟ ਮੌਜੂਦ ਹੈ (ਜਾਂ ਮੌਜੂਦਾ ਡਾਇਰੈਕਟਰੀ ਜਦੋਂ ਕੋਈ ਫਾਇਲ ਨਿਰਧਾਰਤ ਨਾ ਕੀਤੀ ਗਈ ਹੋਵੇ)।

• PYTHONPATH (ਡਾਇਰੈਕਟਰੀ ਨਾਮਾਂ ਦੀ ਇੱਕ ਸੂਚੀ, ਜਿਸਦਾ ਸੰਟੈਕਸ shell ਚਲ PATH ਵਰਗਾ ਹੀ ਹੁੰਦਾ ਹੈ)।

• ਇੰਸਟਾਲੇਸ਼ਨ 'ਤੇ ਨਿਰਭਰ ਮੂਲ ਮੁੱਲ (ਰਵਾਇਤੀ ਤੌਰ 'ਤੇ ਇਸ ਵਿੱਚ site-packages ਡਾਇਰੈਕਟਰੀ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ, ਜਿਸਨੂੰ site ਮੌਡਿਊਲ ਸੰਭਾਲਦਾ ਹੈ)।

ਹੋਰ ਵੇਰਵੇ The initialization of the sys.path module search path ਵਿੱਚ ਉਪਲਬਧ ਹਨ।

Note

ਜਿਨ੍ਹਾਂ ਫਾਇਲ ਸਿਸਟਮਾਂ ਵਿੱਚ symlink ਦਾ ਸਮਰਥਨ ਹੁੰਦਾ ਹੈ, ਉੱਥੇ ਇਨਪੁੱਟ ਸਕ੍ਰਿਪਟ ਵਾਲੀ ਡਾਇਰੈਕਟਰੀ symlink ਨੂੰ ਫਾਲੋ ਕਰਨ ਤੋਂ ਬਾਅਦ ਨਿਰਧਾਰਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, symlink ਵਾਲੀ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਮੌਡਿਊਲ ਖੋਜ ਮਾਰਗ ਵਿੱਚ ਸ਼ਾਮਲ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ।

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

6.1.3. "ਕੰਪਾਈਲ ਕੀਤੀਆਂ" Python ਫਾਇਲਾਂ

ਮੌਡਿਊਲਾਂ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਲੋਡ ਕਰਨ ਲਈ, Python ਹਰ ਮੌਡਿਊਲ ਦੇ ਕੰਪਾਈਲ ਕੀਤੇ ਸੰਸਕਰਣ ਨੂੰ __pycache__ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ module.version.pyc ਨਾਮ ਹੇਠ ਸੰਭਾਲਦਾ ਹੈ, ਜਿੱਥੇ version ਕੰਪਾਈਲ ਕੀਤੀ ਫਾਇਲ ਦੇ ਫਾਰਮੈਟ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ; ਇਸ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ Python ਦਾ ਸੰਸਕਰਣ ਨੰਬਰ ਹੁੰਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, CPython 3.3 ਵਿੱਚ spam.py ਦਾ ਕੰਪਾਈਲ ਕੀਤਾ ਸੰਸਕਰਣ __pycache__/spam.cpython-33.pyc ਵਜੋਂ ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਨਾਮਕਰਨ ਵਿਧੀ Python ਦੇ ਵੱਖ-ਵੱਖ ਸੰਸਕਰਣਾਂ ਅਤੇ ਰਿਲੀਜ਼ਾਂ ਦੇ ਕੰਪਾਈਲ ਕੀਤੇ ਮੌਡਿਊਲਾਂ ਨੂੰ ਇੱਕੱਠੇ ਮੌਜੂਦ ਰਹਿਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ।

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

Python ਦੋ ਸਥਿਤੀਆਂ ਵਿੱਚ cache ਦੀ ਜਾਂਚ ਨਹੀਂ ਕਰਦਾ। ਪਹਿਲਾਂ, ਜਦੋਂ ਕੋਈ ਮੌਡਿਊਲ ਸਿੱਧੇ ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਲੋਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ Python ਹਮੇਸ਼ਾਂ ਉਸਨੂੰ ਦੁਬਾਰਾ ਕੰਪਾਈਲ ਕਰਦਾ ਹੈ ਅਤੇ ਨਤੀਜਾ ਸੰਭਾਲਦਾ ਨਹੀਂ। ਦੂਜਾ, ਜੇ ਕੋਈ ਸਰੋਤ ਮੌਡਿਊਲ ਮੌਜੂਦ ਨਹੀਂ ਹੈ ਤਾਂ cache ਦੀ ਜਾਂਚ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ। ਸਿਰਫ਼ ਕੰਪਾਈਲ ਕੀਤੇ ਵੰਡ-ਸੰਸਕਰਣ (compiled-only distribution) ਦਾ ਸਮਰਥਨ ਕਰਨ ਲਈ, ਕੰਪਾਈਲ ਕੀਤਾ ਮੌਡਿਊਲ ਸਰੋਤ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਸਰੋਤ ਮੌਡਿਊਲ ਮੌਜੂਦ ਨਹੀਂ ਹੋਣਾ ਚਾਹੀਦਾ।

ਮਾਹਿਰਾਂ ਲਈ ਕੁਝ ਸੁਝਾਅ:

• ਤੁਸੀਂ ਕੰਪਾਈਲ ਕੀਤੇ ਮੌਡਿਊਲ ਦਾ ਆਕਾਰ ਘਟਾਉਣ ਲਈ Python ਕਮਾਂਡ ਨਾਲ -O ਜਾਂ -OO ਵਿਕਲਪ ਵਰਤ ਸਕਦੇ ਹੋ। -O ਵਿਕਲਪ assert ਕਥਨਾਂ ਨੂੰ ਹਟਾਉਂਦਾ ਹੈ, ਜਦਕਿ -OO ਵਿਕਲਪ assert ਕਥਨਾਂ ਅਤੇ __doc__ ਸਤਰਾਂ ਦੋਵਾਂ ਨੂੰ ਹਟਾਉਂਦਾ ਹੈ। ਕਿਉਂਕਿ ਕੁਝ ਪ੍ਰੋਗਰਾਮ ਇਨ੍ਹਾਂ ਉੱਤੇ ਨਿਰਭਰ ਹੋ ਸਕਦੇ ਹਨ, ਇਸ ਲਈ ਇਹ ਵਿਕਲਪ ਕੇਵਲ ਤਦ ਹੀ ਵਰਤੋ ਜਦੋਂ ਤੁਹਾਨੂੰ ਪੂਰੀ ਜਾਣਕਾਰੀ ਹੋਵੇ। "Optimized" ਮੌਡਿਊਲਾਂ ਵਿੱਚ opt- ਟੈਗ ਹੁੰਦਾ ਹੈ ਅਤੇ ਇਹ ਆਮ ਤੌਰ 'ਤੇ ਛੋਟੇ ਹੁੰਦੇ ਹਨ। ਭਵਿੱਖ ਦੀਆਂ ਰਿਲੀਜ਼ਾਂ ਵਿੱਚ optimization ਦੇ ਪ੍ਰਭਾਵ ਬਦਲ ਸਕਦੇ ਹਨ।

• ਕੋਈ ਪ੍ਰੋਗਰਾਮ .pyc ਫਾਇਲ ਤੋਂ ਪੜ੍ਹੇ ਜਾਣ 'ਤੇ .py ਫਾਇਲ ਨਾਲੋਂ ਤੇਜ਼ ਨਹੀਂ ਚਲਦਾ; .pyc ਫਾਇਲਾਂ ਦਾ ਕੇਵਲ ਇਹ ਫਾਇਦਾ ਹੈ ਕਿ ਉਹ ਤੇਜ਼ੀ ਨਾਲ ਲੋਡ ਹੁੰਦੀਆਂ ਹਨ।

• compileall ਮੌਡਿਊਲ ਕਿਸੇ ਡਾਇਰੈਕਟਰੀ ਦੇ ਸਾਰੇ ਮੌਡਿਊਲਾਂ ਲਈ .pyc ਫਾਇਲਾਂ ਬਣਾ ਸਕਦਾ ਹੈ।

• ਇਸ ਪ੍ਰਕਿਰਿਆ ਬਾਰੇ ਹੋਰ ਵੇਰਵੇ, ਜਿਸ ਵਿੱਚ ਫੈਸਲਿਆਂ ਦਾ ਇੱਕ flow chart ਵੀ ਸ਼ਾਮਲ ਹੈ, PEP 3147 ਵਿੱਚ ਉਪਲਬਧ ਹਨ।

6.2. ਮਿਆਰੀ ਮੌਡਿਊਲ

Python ਮਿਆਰੀ ਮੌਡਿਊਲਾਂ ਦੀ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਨਾਲ ਆਉਂਦਾ ਹੈ, ਜਿਸਦਾ ਵੇਰਵਾ ਇੱਕ ਵੱਖਰੇ ਦਸਤਾਵੇਜ਼ Python Library Reference (ਅੱਗੇ "Library Reference") ਵਿੱਚ ਦਿੱਤਾ ਗਿਆ ਹੈ। ਕੁਝ ਮੌਡਿਊਲ ਇੰਟਰਪ੍ਰੀਟਰ ਵਿੱਚ ਹੀ built-in ਹੁੰਦੇ ਹਨ; ਇਹ ਉਹਨਾਂ ਕਾਰਵਾਈਆਂ ਤੱਕ ਪਹੁੰਚ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ ਜੋ ਭਾਸ਼ਾ ਦੇ ਮੁੱਖ ਹਿੱਸੇ ਦਾ ਭਾਗ ਨਹੀਂ ਹਨ, ਪਰ ਕਾਰਗੁਜ਼ਾਰੀ ਜਾਂ operating system ਦੀਆਂ ਮੁੱਢਲੀਆਂ ਸਹੂਲਤਾਂ ਜਿਵੇਂ system calls ਤੱਕ ਪਹੁੰਚ ਦੇਣ ਲਈ ਸ਼ਾਮਲ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ। ਅਜਿਹੇ ਮੌਡਿਊਲਾਂ ਦਾ ਸਮੂਹ ਇੱਕ configuration ਵਿਕਲਪ ਹੈ ਅਤੇ ਇਹ ਅਧਾਰਭੂਤ platform ਉੱਤੇ ਵੀ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, winreg ਮੌਡਿਊਲ ਸਿਰਫ਼ Windows ਸਿਸਟਮਾਂ ਉੱਤੇ ਉਪਲਬਧ ਹੈ। ਇੱਕ ਖਾਸ ਮੌਡਿਊਲ ਜਿਸ ਉੱਤੇ ਧਿਆਨ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ, ਉਹ ਹੈ sys, ਜੋ ਹਰ Python ਇੰਟਰਪ੍ਰੀਟਰ ਵਿੱਚ built-in ਹੁੰਦਾ ਹੈ। sys.ps1 ਅਤੇ sys.ps2 ਚਲ primary ਅਤੇ secondary prompt ਲਈ ਵਰਤੀਆਂ ਜਾਣ ਵਾਲੀਆਂ ਸਤਰਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਨ:

>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print('Yuck!')
Yuck!
C>

ਇਹ ਦੋਵੇਂ ਚਲ ਕੇਵਲ ਤਦ ਹੀ ਪਰਿਭਾਸ਼ਿਤ ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਇੰਟਰਪ੍ਰੀਟਰ interactive mode ਵਿੱਚ ਚੱਲ ਰਿਹਾ ਹੋਵੇ।

ਚਲ sys.path ਸਤਰਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਹੈ ਜੋ ਮੌਡਿਊਲਾਂ ਲਈ ਇੰਟਰਪ੍ਰੀਟਰ ਦਾ ਖੋਜ ਮਾਰਗ ਨਿਰਧਾਰਤ ਕਰਦੀ ਹੈ। ਇਸਨੂੰ PYTHONPATH environment variable ਤੋਂ ਮਿਲੇ ਮੂਲ ਮਾਰਗ ਜਾਂ, ਜੇ PYTHONPATH ਨਿਰਧਾਰਤ ਨਾ ਹੋਵੇ, built-in ਮੂਲ ਮਾਰਗ ਨਾਲ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਤੁਸੀਂ ਇਸਨੂੰ ਆਮ list operations ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਦਲ ਸਕਦੇ ਹੋ:

>>> import sys
>>> sys.path.append('/ufs/guido/lib/python')

6.3. dir() ਫੰਕਸ਼ਨ

built-in ਫੰਕਸ਼ਨ dir() ਦੀ ਵਰਤੋਂ ਇਹ ਜਾਣਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਿ ਕੋਈ ਮੌਡਿਊਲ ਕਿਹੜੇ ਨਾਮ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ। ਇਹ ਸਤਰਾਂ ਦੀ ਇੱਕ ਕ੍ਰਮਬੱਧ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ:

>>> import fibo, sys
>>> dir(fibo)
['__name__', 'fib', 'fib2']
>>> dir(sys)
['__breakpointhook__', '__displayhook__', '__doc__', '__excepthook__',
 '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__',
 '__stderr__', '__stdin__', '__stdout__', '__unraisablehook__',
 '_clear_type_cache', '_current_frames', '_debugmallocstats', '_framework',
 '_getframe', '_git', '_home', '_xoptions', 'abiflags', 'addaudithook',
 'api_version', 'argv', 'audit', 'base_exec_prefix', 'base_prefix',
 'breakpointhook', 'builtin_module_names', 'byteorder', 'call_tracing',
 'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', 'exc_info',
 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info',
 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_origin_tracking_depth',
 'getallocatedblocks', 'getdefaultencoding', 'getdlopenflags',
 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile',
 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval',
 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',
 'intern', 'is_finalizing', 'last_traceback', 'last_type', 'last_value',
 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks',
 'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', 'pycache_prefix',
 'set_asyncgen_hooks', 'set_coroutine_origin_tracking_depth', 'setdlopenflags',
 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr',
 'stdin', 'stdout', 'thread_info', 'unraisablehook', 'version', 'version_info',
 'warnoptions']

ਬਿਨਾਂ ਕਿਸੇ ਆਰਗੂਮੈਂਟ ਦੇ, dir() ਉਹਨਾਂ ਨਾਮਾਂ ਦੀ ਸੂਚੀ ਦਿਖਾਉਂਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਮੌਜੂਦਾ ਸਮੇਂ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੇ ਹਨ:

>>> a = [1, 2, 3, 4, 5]
>>> import fibo
>>> fib = fibo.fib
>>> dir()
['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']

ਧਿਆਨ ਦਿਓ ਕਿ ਇਹ ਹਰ ਕਿਸਮ ਦੇ ਨਾਮਾਂ ਦੀ ਸੂਚੀ ਦਿੰਦਾ ਹੈ: variables, modules, functions ਆਦਿ।

dir() built-in functions ਅਤੇ variables ਦੇ ਨਾਮਾਂ ਦੀ ਸੂਚੀ ਨਹੀਂ ਦਿੰਦਾ। ਜੇ ਤੁਸੀਂ ਉਹਨਾਂ ਦੀ ਸੂਚੀ ਦੇਖਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਉਹ ਮਿਆਰੀ ਮੌਡਿਊਲ builtins ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਹਨ:

>>> import builtins
>>> dir(builtins)
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException',
 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning',
 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError',
 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning',
 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False',
 'FileExistsError', 'FileNotFoundError', 'FloatingPointError',
 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError',
 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError',
 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError',
 'MemoryError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented',
 'NotImplementedError', 'OSError', 'OverflowError',
 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError',
 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning',
 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError',
 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError',
 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError',
 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning',
 'ValueError', 'Warning', 'ZeroDivisionError', '_', '__build_class__',
 '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs',
 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable',
 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits',
 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit',
 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr',
 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass',
 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview',
 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property',
 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice',
 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars',
 'zip']

6.4. ਪੈਕੇਜ

ਪੈਕੇਜ Python ਦੇ module namespace ਨੂੰ ਵਿਵਸਥਿਤ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ ਹਨ, ਜਿਸ ਵਿੱਚ "dotted module names" ਵਰਤੇ ਜਾਂਦੇ ਹਨ। ਉਦਾਹਰਨ ਵਜੋਂ, ਮੌਡਿਊਲ ਨਾਮ A.B ਪੈਕੇਜ A ਦੇ ਅੰਦਰ ਮੌਜੂਦ B ਨਾਮ ਦੇ submodule ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਜਿਵੇਂ ਮੌਡਿਊਲ ਵੱਖ-ਵੱਖ ਮੌਡਿਊਲ ਲੇਖਕਾਂ ਨੂੰ ਇੱਕ-ਦੂਜੇ ਦੇ global variable ਨਾਮਾਂ ਦੀ ਚਿੰਤਾ ਤੋਂ ਬਚਾਉਂਦੇ ਹਨ, ਉਸੇ ਤਰ੍ਹਾਂ dotted module names NumPy ਜਾਂ Pillow ਵਰਗੇ multi-module ਪੈਕੇਜਾਂ ਦੇ ਲੇਖਕਾਂ ਨੂੰ ਇੱਕ-ਦੂਜੇ ਦੇ ਮੌਡਿਊਲ ਨਾਮਾਂ ਦੀ ਚਿੰਤਾ ਤੋਂ ਬਚਾਉਂਦੇ ਹਨ।

ਮੰਨ ਲਓ ਕਿ ਤੁਸੀਂ sound files ਅਤੇ sound data ਨੂੰ ਇੱਕਸਾਰ ਢੰਗ ਨਾਲ ਸੰਭਾਲਣ ਲਈ ਮੌਡਿਊਲਾਂ ਦਾ ਇੱਕ ਸਮੂਹ (ਇੱਕ "package") ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ। ਕਈ ਵੱਖ-ਵੱਖ sound file formats ਹੁੰਦੇ ਹਨ (ਜਿਨ੍ਹਾਂ ਨੂੰ ਆਮ ਤੌਰ 'ਤੇ ਉਹਨਾਂ ਦੇ extension ਰਾਹੀਂ ਪਛਾਣਿਆ ਜਾਂਦਾ ਹੈ, ਜਿਵੇਂ .wav, .aiff, .au)। ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਵੱਖ-ਵੱਖ ਫਾਰਮੈਟਾਂ ਵਿਚਕਾਰ ਰੂਪਾਂਤਰਨ ਲਈ ਮੌਡਿਊਲਾਂ ਦਾ ਵਧਦਾ ਹੋਇਆ ਸੰਗ੍ਰਹਿ ਤਿਆਰ ਅਤੇ ਸੰਭਾਲਣਾ ਪੈ ਸਕਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ sound data ਉੱਤੇ ਕਈ ਤਰ੍ਹਾਂ ਦੀਆਂ ਕਾਰਵਾਈਆਂ (ਜਿਵੇਂ mixing, echo ਜੋੜਨਾ, equalizer ਲਗਾਉਣਾ ਜਾਂ artificial stereo effect ਬਣਾਉਣਾ) ਵੀ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ। ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਇਹ ਕੰਮ ਕਰਨ ਲਈ ਵੀ ਕਈ ਮੌਡਿਊਲ ਲਿਖਣੇ ਪੈਣਗੇ। ਹੇਠਾਂ ਤੁਹਾਡੇ package ਦੀ ਇੱਕ ਸੰਭਾਵਿਤ ਬਣਤਰ (hierarchical filesystem ਦੇ ਰੂਪ ਵਿੱਚ) ਦਿੱਤੀ ਗਈ ਹੈ:

sound/                          Top-level package
      __init__.py               Initialize the sound package
      formats/                  Subpackage for file format conversions
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  Subpackage for sound effects
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  Subpackage for filters
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...

ਜਦੋਂ ਕਿਸੇ ਪੈਕੇਜ ਨੂੰ import ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ Python sys.path ਵਿੱਚ ਦਿੱਤੀਆਂ ਡਾਇਰੈਕਟਰੀਆਂ ਵਿੱਚ ਪੈਕੇਜ ਦੀ ਉਪ-ਡਾਇਰੈਕਟਰੀ ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ।

Python ਨੂੰ ਕਿਸੇ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਪੈਕੇਜ ਵਜੋਂ ਮੰਨਣ ਲਈ __init__.py ਫਾਇਲਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ (ਜੇਕਰ namespace package ਵਰਗੀ ਤੁਲਨਾਤਮਕ ਤੌਰ 'ਤੇ ਉੱਨਤ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਨਾ ਕੀਤੀ ਜਾ ਰਹੀ ਹੋਵੇ)। ਇਹ string ਵਰਗੇ ਆਮ ਨਾਮ ਵਾਲੀਆਂ ਡਾਇਰੈਕਟਰੀਆਂ ਨੂੰ ਮੌਡਿਊਲ ਖੋਜ ਮਾਰਗ ਵਿੱਚ ਬਾਅਦ ਵਿੱਚ ਆਉਣ ਵਾਲੇ ਵੈਧ ਮੌਡਿਊਲਾਂ ਨੂੰ ਅਣਜਾਣੇ ਵਿੱਚ ਲੁਕਾਉਣ ਤੋਂ ਰੋਕਦਾ ਹੈ। ਸਭ ਤੋਂ ਸਧਾਰਣ ਹਾਲਤ ਵਿੱਚ __init__.py ਕੇਵਲ ਇੱਕ ਖਾਲੀ ਫਾਇਲ ਹੋ ਸਕਦੀ ਹੈ, ਪਰ ਇਹ ਪੈਕੇਜ ਲਈ ਸ਼ੁਰੂਆਤੀਕਰਨ ਕੋਡ ਵੀ ਚਲਾ ਸਕਦੀ ਹੈ ਜਾਂ __all__ ਚਲ ਦਾ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੀ ਹੈ, ਜਿਸਦਾ ਵੇਰਵਾ ਅੱਗੇ ਦਿੱਤਾ ਗਿਆ ਹੈ।

ਪੈਕੇਜ ਦੇ ਵਰਤੋਂਕਾਰ ਪੈਕੇਜ ਵਿੱਚੋਂ ਵੱਖ-ਵੱਖ ਮੌਡਿਊਲ import ਕਰ ਸਕਦੇ ਹਨ, ਉਦਾਹਰਨ ਵਜੋਂ:

import sound.effects.echo

ਇਹ sound.effects.echo submodule ਨੂੰ ਲੋਡ ਕਰਦਾ ਹੈ। ਇਸਦਾ ਹਵਾਲਾ ਇਸਦੇ ਪੂਰੇ ਨਾਮ ਨਾਲ ਦੇਣਾ ਲਾਜ਼ਮੀ ਹੈ।:

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

ਇਸ submodule ਨੂੰ import ਕਰਨ ਦਾ ਇੱਕ ਹੋਰ ਤਰੀਕਾ ਇਹ ਹੈ:

from sound.effects import echo

ਇਹ ਵੀ echo submodule ਨੂੰ ਲੋਡ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਪੈਕੇਜ prefix ਤੋਂ ਬਿਨਾਂ ਉਪਲਬਧ ਕਰਵਾਉਂਦਾ ਹੈ, ਇਸ ਲਈ ਇਸਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਤਰੀਕੇ ਨਾਲ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ:

echo.echofilter(input, output, delay=0.7, atten=4)

ਇੱਕ ਹੋਰ ਤਰੀਕਾ ਇਹ ਹੈ ਕਿ ਲੋੜੀਂਦੇ function ਜਾਂ variable ਨੂੰ ਸਿੱਧਾ import ਕਰ ਲਿਆ ਜਾਵੇ:

from sound.effects.echo import echofilter

ਦੁਬਾਰਾ, ਇਹ echo submodule ਨੂੰ ਲੋਡ ਕਰਦਾ ਹੈ, ਪਰ ਇਸ ਵਾਰ ਇਸਦਾ echofilter() function ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਉਪਲਬਧ ਹੋ ਜਾਂਦਾ ਹੈ:

echofilter(input, output, delay=0.7, atten=4)

ਧਿਆਨ ਦਿਓ ਕਿ ਜਦੋਂ from package import item ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ item ਪੈਕੇਜ ਦਾ ਸਬ-ਮੋਡੀਊਲ (ਜਾਂ ਸਬ-ਪੈਕੇਜ) ਹੋ ਸਕਦਾ ਹੈ, ਜਾਂ ਪੈਕੇਜ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਕੋਈ ਹੋਰ ਨਾਮ, ਜਿਵੇਂ ਕਿ ਫੰਕਸ਼ਨ, ਕਲਾਸ ਜਾਂ ਵੇਰੀਏਬਲ। import ਕਥਨ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਜਾਂਚਦਾ ਹੈ ਕਿ item ਪੈਕੇਜ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਹੈ ਜਾਂ ਨਹੀਂ; ਜੇ ਨਹੀਂ, ਤਾਂ ਇਹ ਮੰਨ ਲੈਂਦਾ ਹੈ ਕਿ ਇਹ ਇੱਕ ਮੋਡੀਊਲ ਹੈ ਅਤੇ ਇਸਨੂੰ ਲੋਡ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ। ਜੇ ਇਹ ਇਸਨੂੰ ਲੱਭਣ ਵਿੱਚ ਅਸਫਲ ਰਹਿੰਦਾ ਹੈ, ਤਾਂ ਇੱਕ ImportError ਅਪਵਾਦ ਉਠਾਇਆ ਜਾਂਦਾ ਹੈ।

ਇਸਦੇ ਉਲਟ, ਜਦੋਂ import item.subitem.subsubitem ਵਰਗਾ syntax ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਆਖਰੀ item ਤੋਂ ਇਲਾਵਾ ਹਰ item ਇੱਕ package ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਆਖਰੀ item module ਜਾਂ package ਹੋ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਪਿਛਲੇ item ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਕੋਈ class, function ਜਾਂ variable ਨਹੀਂ ਹੋ ਸਕਦਾ।

6.4.1. ਪੈਕੇਜ ਤੋਂ Import ਕਰਨਾ

ਹੁਣ ਕੀ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਵਰਤੋਂਕਾਰ from sound.effects import * ਲਿਖਦਾ ਹੈ? ਆਦਰਸ਼ ਤੌਰ 'ਤੇ ਉਮੀਦ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਕਿ Python ਫਾਇਲ ਸਿਸਟਮ ਵਿੱਚ ਜਾ ਕੇ ਪੈਕੇਜ ਵਿੱਚ ਮੌਜੂਦ ਸਾਰੇ submodules ਲੱਭੇ ਅਤੇ ਉਹਨਾਂ ਨੂੰ import ਕਰ ਲਵੇ। ਪਰ ਇਸ ਵਿੱਚ ਕਾਫ਼ੀ ਸਮਾਂ ਲੱਗ ਸਕਦਾ ਹੈ ਅਤੇ submodules ਨੂੰ import ਕਰਨ ਨਾਲ ਅਣਚਾਹੇ side-effects ਵੀ ਹੋ ਸਕਦੇ ਹਨ, ਜੋ ਸਿਰਫ਼ ਉਸ ਵੇਲੇ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ ਜਦੋਂ ਕਿਸੇ submodule ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ import ਕੀਤਾ ਜਾਵੇ।

ਇਸ ਸਮੱਸਿਆ ਦਾ ਇਕੱਲਾ ਹੱਲ ਇਹ ਹੈ ਕਿ ਪੈਕੇਜ ਦਾ ਲੇਖਕ ਪੈਕੇਜ ਦਾ ਇੱਕ ਸਪਸ਼ਟ index ਮੁਹੱਈਆ ਕਰੇ। import ਕਥਨ ਹੇਠਾਂ ਦਿੱਤੇ ਨਿਯਮ ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹੈ: ਜੇ ਪੈਕੇਜ ਦੀ __init__.py ਫਾਇਲ ਵਿੱਚ __all__ ਨਾਮ ਦੀ ਸੂਚੀ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੀ ਗਈ ਹੋਵੇ, ਤਾਂ from package import * ਮਿਲਣ 'ਤੇ ਉਸਨੂੰ ਉਹਨਾਂ ਮੌਡਿਊਲਾਂ ਦੀ ਸੂਚੀ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ import ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਪੈਕੇਜ ਦੇ ਨਵੇਂ ਸੰਸਕਰਣ ਜਾਰੀ ਹੋਣ 'ਤੇ ਇਸ ਸੂਚੀ ਨੂੰ ਅਪਡੇਟ ਰੱਖਣਾ ਲੇਖਕ ਦੀ ਜ਼ਿੰਮੇਵਾਰੀ ਹੁੰਦੀ ਹੈ। ਪੈਕੇਜ ਲੇਖਕ ਇਹ ਵੀ ਫੈਸਲਾ ਕਰ ਸਕਦੇ ਹਨ ਕਿ ਉਹ ਇਸਦੀ ਸਹਾਇਤਾ ਨਾ ਕਰਨ, ਜੇ ਉਹਨਾਂ ਨੂੰ ਆਪਣੇ ਪੈਕੇਜ ਤੋਂ * import ਕਰਨ ਦੀ ਕੋਈ ਲੋੜ ਨਾ ਲੱਗੇ। ਉਦਾਹਰਨ ਲਈ, sound/effects/__init__.py ਫਾਇਲ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤਾ ਕੋਡ ਹੋ ਸਕਦਾ ਹੈ:

__all__ = ["echo", "surround", "reverse"]

ਇਸਦਾ ਮਤਲਬ ਹੋਵੇਗਾ ਕਿ from sound.effects import * sound.effects ਪੈਕੇਜ ਦੇ ਤਿੰਨ ਨਾਮਿਤ submodules ਨੂੰ import ਕਰੇਗਾ।

ਧਿਆਨ ਰੱਖੋ ਕਿ submodules ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਨਾਮਾਂ ਦੁਆਰਾ shadow ਹੋ ਸਕਦੇ ਹਨ। ਉਦਾਹਰਨ ਵਜੋਂ, ਜੇ ਤੁਸੀਂ sound/effects/__init__.py ਵਿੱਚ reverse ਨਾਮ ਦਾ ਇੱਕ function ਜੋੜ ਦਿਓ, ਤਾਂ from sound.effects import * ਸਿਰਫ਼ echo ਅਤੇ surround submodules ਨੂੰ import ਕਰੇਗਾ, ਪਰ reverse submodule ਨੂੰ ਨਹੀਂ, ਕਿਉਂਕਿ ਉਹ ਸਥਾਨਕ reverse function ਦੁਆਰਾ shadow ਹੋ ਗਿਆ ਹੈ:

__all__ = [
    "echo",      # refers to the 'echo.py' file
    "surround",  # refers to the 'surround.py' file
    "reverse",   # !!! refers to the 'reverse' function now !!!
]

def reverse(msg: str):  # <-- this name shadows the 'reverse.py' submodule
    return msg[::-1]    #     in the case of a 'from sound.effects import *'

ਜੇ __all__ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ, ਤਾਂ from sound.effects import * ਕਥਨ sound.effects ਪੈਕੇਜ ਦੇ ਸਾਰੇ submodules ਨੂੰ ਮੌਜੂਦਾ namespace ਵਿੱਚ import ਨਹੀਂ ਕਰਦਾ। ਇਹ ਸਿਰਫ਼ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ sound.effects ਪੈਕੇਜ import ਹੋ ਚੁੱਕਾ ਹੈ (ਅਤੇ ਸੰਭਵ ਹੈ ਕਿ __init__.py ਵਿੱਚ ਮੌਜੂਦ initialization code ਵੀ ਚੱਲਿਆ ਹੋਵੇ), ਅਤੇ ਫਿਰ ਪੈਕੇਜ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਨਾਮਾਂ ਨੂੰ import ਕਰਦਾ ਹੈ। ਇਸ ਵਿੱਚ __init__.py ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਨਾਮ (ਅਤੇ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਲੋਡ ਕੀਤੇ submodules) ਵੀ ਸ਼ਾਮਲ ਹਨ। ਇਸ ਵਿੱਚ ਉਹ submodules ਵੀ ਸ਼ਾਮਲ ਹਨ ਜੋ ਪਹਿਲਾਂ ਦੇ import ਕਥਨਾਂ ਦੁਆਰਾ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਲੋਡ ਕੀਤੇ ਗਏ ਸਨ। ਹੇਠਾਂ ਦਿੱਤਾ ਕੋਡ ਵੇਖੋ:

import sound.effects.echo
import sound.effects.surround
from sound.effects import *

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ echo ਅਤੇ surround ਮੌਡਿਊਲ ਮੌਜੂਦਾ namespace ਵਿੱਚ import ਹੋ ਜਾਂਦੇ ਹਨ, ਕਿਉਂਕਿ from...import ਕਥਨ ਦੇ ਚੱਲਣ ਵੇਲੇ ਉਹ sound.effects ਪੈਕੇਜ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਹਨ। (ਇਹ __all__ ਪਰਿਭਾਸ਼ਿਤ ਹੋਣ 'ਤੇ ਵੀ ਕੰਮ ਕਰਦਾ ਹੈ।)

ਹਾਲਾਂਕਿ ਕੁਝ ਮੌਡਿਊਲ ਇਸ ਤਰ੍ਹਾਂ ਬਣਾਏ ਜਾਂਦੇ ਹਨ ਕਿ import * ਵਰਤਣ 'ਤੇ ਸਿਰਫ਼ ਕੁਝ ਖਾਸ ਪੈਟਰਨਾਂ ਵਾਲੇ ਨਾਮ ਹੀ export ਕੀਤੇ ਜਾਣ, ਫਿਰ ਵੀ production code ਵਿੱਚ ਇਸਨੂੰ ਚੰਗਾ ਅਭਿਆਸ ਨਹੀਂ ਮੰਨਿਆ ਜਾਂਦਾ।

ਯਾਦ ਰੱਖੋ, from package import specific_submodule ਵਰਤਣ ਵਿੱਚ ਕੋਈ ਗਲਤੀ ਨਹੀਂ ਹੈ! ਦਰਅਸਲ, ਇਹੀ ਸਿਫ਼ਾਰਸ਼ ਕੀਤੀ ਗਈ notation ਹੈ, ਜਦ ਤੱਕ import ਕਰਨ ਵਾਲੇ ਮੌਡਿਊਲ ਨੂੰ ਵੱਖ-ਵੱਖ ਪੈਕੇਜਾਂ ਤੋਂ ਇੱਕੋ ਨਾਮ ਵਾਲੇ submodules ਵਰਤਣ ਦੀ ਲੋੜ ਨਾ ਹੋਵੇ।

6.4.2. ਪੈਕੇਜ ਅੰਦਰਲੇ ਹਵਾਲੇ

ਜਦੋਂ ਪੈਕੇਜਾਂ ਨੂੰ subpackages ਵਿੱਚ ਵਿਵਸਥਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ (ਜਿਵੇਂ ਉਦਾਹਰਨ ਵਿੱਚ sound ਪੈਕੇਜ), ਤਾਂ ਤੁਸੀਂ sibling packages ਦੇ submodules ਦਾ ਹਵਾਲਾ ਦੇਣ ਲਈ absolute imports ਵਰਤ ਸਕਦੇ ਹੋ। ਉਦਾਹਰਨ ਵਜੋਂ, ਜੇ sound.filters.vocoder ਮੌਡਿਊਲ ਨੂੰ sound.effects ਪੈਕੇਜ ਵਿੱਚ ਮੌਜੂਦ echo ਮੌਡਿਊਲ ਦੀ ਲੋੜ ਹੋਵੇ, ਤਾਂ ਇਹ from sound.effects import echo ਵਰਤ ਸਕਦਾ ਹੈ।

ਤੁਸੀਂ from module import name ਰੂਪ ਵਾਲੇ import ਕਥਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ relative imports ਵੀ ਲਿਖ ਸਕਦੇ ਹੋ। ਇਹ imports relative import ਵਿੱਚ ਸ਼ਾਮਲ ਮੌਜੂਦਾ ਅਤੇ parent packages ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਸ਼ੁਰੂਆਤੀ dots ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ। ਉਦਾਹਰਨ ਵਜੋਂ, surround ਮੌਡਿਊਲ ਤੋਂ ਤੁਸੀਂ ਇਹ ਵਰਤ ਸਕਦੇ ਹੋ:

from . import echo
from .. import formats
from ..filters import equalizer

ਧਿਆਨ ਦਿਓ ਕਿ relative imports ਮੌਜੂਦਾ ਮੌਡਿਊਲ ਦੇ ਪੈਕੇਜ ਨਾਮ 'ਤੇ ਆਧਾਰਿਤ ਹੁੰਦੇ ਹਨ। ਕਿਉਂਕਿ main module ਦਾ ਕੋਈ ਪੈਕੇਜ ਨਹੀਂ ਹੁੰਦਾ, ਇਸ ਲਈ Python ਐਪਲੀਕੇਸ਼ਨ ਦੇ main module ਵਜੋਂ ਵਰਤੇ ਜਾਣ ਵਾਲੇ ਮੌਡਿਊਲਾਂ ਨੂੰ ਹਮੇਸ਼ਾਂ absolute imports ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ।

ਫੁਟਨੋਟ

[1]

ਅਸਲ ਵਿੱਚ function definitions ਵੀ ਅਜਿਹੇ 'statements' ਹਨ ਜੋ 'execute' ਕੀਤੇ ਜਾਂਦੇ ਹਨ; module-level function definition ਦੇ execute ਹੋਣ ਨਾਲ ਉਸ function ਦਾ ਨਾਮ ਮੌਡਿਊਲ ਦੇ global namespace ਵਿੱਚ ਸ਼ਾਮਲ ਹੋ ਜਾਂਦਾ ਹੈ।