ਪਾਈਥਨ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਾਵਾਂ ਵਿੱਚ *args ਅਤੇ **kwargs ਨੂੰ ਸਮਝਣਾ

ਪਾਈਥਨ ਦੇ ਫੰਕਸ਼ਨ ਪੈਰਾਮੀਟਰਾਂ ਦੀ ਪੜਚੋਲ ਕਰਨਾ

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

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

ਪਾਈਥਨ ਵਿੱਚ *args ਅਤੇ **kwargs ਵਿੱਚ ਡੂੰਘੀ ਡੁਬਕੀ ਕਰੋ

ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਦਰਸਾਉਂਦੀਆਂ ਹਨ ਕਿ ਕਿਵੇਂ ਵਰਤੋਂ ਕਰਨੀ ਹੈ *args ਅਤੇ **kwargs ਪਾਈਥਨ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਾਵਾਂ ਵਿੱਚ. ਪਹਿਲੀ ਸਕ੍ਰਿਪਟ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀ ਹੈ foo ਜੋ ਦੋ ਲੋੜੀਂਦੀਆਂ ਦਲੀਲਾਂ ਲੈਂਦਾ ਹੈ, x ਅਤੇ y, ਦੁਆਰਾ ਪ੍ਰਸਤੁਤ ਕੀਤੇ ਕਿਸੇ ਵੀ ਵਾਧੂ ਸਥਿਤੀ ਸੰਬੰਧੀ ਆਰਗੂਮੈਂਟਾਂ ਦੇ ਬਾਅਦ *args. ਕਾਲ ਕਰਨ ਵੇਲੇ foo ਵਾਧੂ ਦਲੀਲਾਂ ਦੇ ਨਾਲ, ਇਹਨਾਂ ਨੂੰ ਇੱਕ ਟੂਪਲ ਦੇ ਰੂਪ ਵਿੱਚ ਕੈਪਚਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਛਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਫੰਕਸ਼ਨ ਨੂੰ ਵੱਖੋ-ਵੱਖਰੀਆਂ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਖੂਬਸੂਰਤੀ ਨਾਲ ਸੰਭਾਲਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਦੂਜਾ ਫੰਕਸ਼ਨ, bar, ਦੁਆਰਾ ਦੋ ਲੋੜੀਂਦੇ ਆਰਗੂਮੈਂਟਾਂ ਅਤੇ ਕੀਵਰਡ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ **kwargs. ਇਹ ਕੀਵਰਡ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਇੱਕ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇਕੱਠਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਫੰਕਸ਼ਨ ਨੂੰ ਲਚਕਦਾਰ ਨਾਮੀ ਇਨਪੁਟਸ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੇ ਯੋਗ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ।

ਦੂਜੀ ਉਦਾਹਰਣ ਸਕ੍ਰਿਪਟ ਪੇਸ਼ ਕਰਦੀ ਹੈ example_function ਅਤੇ greet ਦੀ ਵਰਤੋਂ ਨੂੰ ਹੋਰ ਦਰਸਾਉਣ ਲਈ ਫੰਕਸ਼ਨ *args ਅਤੇ **kwargs. ਦ example_function ਸਥਿਤੀ ਸੰਬੰਧੀ ਅਤੇ ਕੀਵਰਡ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ, ਉਹਨਾਂ ਦੇ ਸੰਗ੍ਰਹਿ ਨੂੰ ਕ੍ਰਮਵਾਰ ਟੂਪਲਾਂ ਅਤੇ ਸ਼ਬਦਕੋਸ਼ਾਂ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈ। ਦ greet ਫੰਕਸ਼ਨ ਇੱਕ ਵਿਹਾਰਕ ਵਰਤੋਂ ਦੇ ਕੇਸ ਨੂੰ ਉਜਾਗਰ ਕਰਦਾ ਹੈ ਜਿੱਥੇ **kwargs ਵਿਕਲਪਿਕ ਕੀਵਰਡ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਇੱਕ ਅਨੁਕੂਲਿਤ ਗ੍ਰੀਟਿੰਗ ਸੰਦੇਸ਼। ਲੀਵਰ ਕਰ ਕੇ get() ਦੇ ਉਤੇ kwargs ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ, ਫੰਕਸ਼ਨ ਇੱਕ ਡਿਫੌਲਟ ਮੁੱਲ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦਾ ਹੈ ਜਦੋਂ ਗ੍ਰੀਟਿੰਗ ਕੀਵਰਡ ਸਪਲਾਈ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਸਲ-ਸੰਸਾਰ ਦ੍ਰਿਸ਼ਾਂ ਵਿੱਚ ਇਹਨਾਂ ਨਿਰਮਾਣਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਲਚਕਤਾ ਅਤੇ ਸ਼ਕਤੀ ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਕਰਦਾ ਹੈ।

def foo(x, y, *args):
    print("Required arguments:", x, y)
    print("Additional arguments:", args)

def bar(x, y, **kwargs):
    print("Required arguments:", x, y)
    print("Keyword arguments:", kwargs)

foo(1, 2, 3, 4, 5)
# Output:
# Required arguments: 1 2
# Additional arguments: (3, 4, 5)

bar(1, 2, a=3, b=4, c=5)
# Output:
# Required arguments: 1 2
# Keyword arguments: {'a': 3, 'b': 4, 'c': 5}

def example_function(*args, **kwargs):
    print("Positional arguments:", args)
    print("Keyword arguments:", kwargs)

example_function(1, 2, 3, a="apple", b="banana")
# Output:
# Positional arguments: (1, 2, 3)
# Keyword arguments: {'a': 'apple', 'b': 'banana'}

def greet(name, *args, **kwargs):
    greeting = kwargs.get('greeting', 'Hello')
    print(f"{greeting}, {name}!")
    if args:
        print("Additional names:", ', '.join(args))

greet("Alice")
# Output: Hello, Alice!

greet("Alice", "Bob", "Charlie", greeting="Hi")
# Output:
# Hi, Alice!
# Additional names: Bob, Charlie

*args ਅਤੇ **kwargs ਦੀ ਉੱਨਤ ਵਰਤੋਂ

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

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

*args ਅਤੇ **kwargs ਨਾਲ ਸਮੇਟਣਾ

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

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