ਟੂਪਲਸ, ਜੋ ਕਿ ਪਾਈਥਨ ਵਿੱਚ ਅਟੱਲ (ਬਦਲਣਯੋਗ) ਕ੍ਰਮ ਵਸਤੂਆਂ ਹਨ।
ਇੱਕ ਸਿੰਗਲ ਐਲੀਮੈਂਟ ਜਾਂ ਖਾਲੀ ਟੂਪਲਸ ਨਾਲ ਟੂਪਲਸ ਬਣਾਉਣ ਵੇਲੇ ਧਿਆਨ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ।
ਹੇਠਾਂ ਦਿੱਤੇ ਵੇਰਵਿਆਂ ਦਾ ਇੱਥੇ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ।
- 1 ਤੱਤ ਦੇ ਨਾਲ ਟੂਪਲ
- ਟੂਪਲ ਗੋਲ ਬਰੈਕਟਾਂ ਨੂੰ ਛੱਡਿਆ ਜਾ ਸਕਦਾ ਹੈ।
- ਖਾਲੀ ਟੂਪਲ
- ਫੰਕਸ਼ਨ ਆਰਗੂਮੈਂਟਾਂ ਵਿੱਚ ਟੂਪਲਸ
1 ਤੱਤ ਦੇ ਨਾਲ ਟੂਪਲ
ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਐਲੀਮੈਂਟ ਨਾਲ ਟੂਪਲ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋ ਅਤੇ ਗੋਲ ਬਰੈਕਟਾਂ () ਦੇ ਅੰਦਰ ਸਿਰਫ਼ ਇੱਕ ਵਸਤੂ ਲਿਖਦੇ ਹੋ, ਤਾਂ ਗੋਲ ਬਰੈਕਟਸ () ਨੂੰ ਅਣਡਿੱਠ ਕੀਤਾ ਜਾਵੇਗਾ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਕੀਤੀ ਜਾਵੇਗੀ ਅਤੇ ਇੱਕ ਟੂਪਲ ਨਹੀਂ ਮੰਨਿਆ ਜਾਵੇਗਾ।
single_tuple_error = (0)
print(single_tuple_error)
print(type(single_tuple_error))
# 0
# <class 'int'>
ਇੱਕ ਤੱਤ ਦੇ ਨਾਲ ਇੱਕ ਟੂਪਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਟ੍ਰੇਲਿੰਗ ਕਾਮੇ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
single_tuple = (0, )
print(single_tuple)
print(type(single_tuple))
# (0,)
# <class 'tuple'>
ਉਦਾਹਰਨ ਲਈ, ਮਲਟੀਪਲ ਟੂਪਲਾਂ ਨੂੰ ਜੋੜਨ ਲਈ + ਆਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਧਿਆਨ ਦਿਓ ਕਿ ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਤੱਤ ਜੋੜਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋ ਅਤੇ ਇੱਕ ਕੌਮਾ ਭੁੱਲ ਜਾਂਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਇੱਕ ਗਲਤੀ ਮਿਲੇਗੀ।
# print((0, 1, 2) + (3))
# TypeError: can only concatenate tuple (not "int") to tuple
print((0, 1, 2) + (3, ))
# (0, 1, 2, 3)
ਟੂਪਲ ਗੋਲ ਬਰੈਕਟਾਂ ਨੂੰ ਛੱਡਿਆ ਜਾ ਸਕਦਾ ਹੈ।
ਇੱਕ ਐਲੀਮੈਂਟ ਵਾਲੇ ਟੂਪਲ ਨੂੰ ਕਾਮੇ ਦੀ ਲੋੜ ਦਾ ਕਾਰਨ ਇਹ ਹੈ ਕਿ ਇੱਕ ਟੂਪਲ ਗੋਲ ਬਰੈਕਟਾਂ () ਵਿੱਚ ਬੰਦ ਮੁੱਲ ਨਹੀਂ ਹੈ, ਪਰ ਇੱਕ ਕੌਮੇ ਦੁਆਰਾ ਵੱਖ ਕੀਤਾ ਮੁੱਲ ਹੈ।
ਇਹ ਕੌਮਾ ਹੈ ਜੋ ਟੂਪਲ ਬਣਾਉਂਦਾ ਹੈ, ਨਾ ਕਿ ਗੋਲ ਬਰੈਕਟਾਂ।
Tuples — Built-in Types — Python 3.10.4 Documentation
ਭਾਵੇਂ ਗੋਲ ਬਰੈਕਟਾਂ () ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜਾਵੇ, ਇਸ ਨੂੰ ਟੂਪਲ ਦੇ ਤੌਰ ‘ਤੇ ਸੰਸਾਧਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
t = 0, 1, 2
print(t)
print(type(t))
# (0, 1, 2)
# <class 'tuple'>
ਨੋਟ ਕਰੋ ਕਿ ਕਿਸੇ ਵਸਤੂ ਦੇ ਬਾਅਦ ਇੱਕ ਬੇਲੋੜੇ ਕਾਮੇ ਨੂੰ ਟੂਪਲ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ।
t_ = 0,
print(t_)
print(type(t_))
# (0,)
# <class 'tuple'>
ਖਾਲੀ ਟੂਪਲ
ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਗੋਲ ਬਰੈਕਟਾਂ () ਨੂੰ ਇੱਕ ਟੂਪਲ ਦੀ ਨੁਮਾਇੰਦਗੀ ਕਰਨ ਵੇਲੇ ਛੱਡਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ ਇੱਕ ਖਾਲੀ ਟੂਪਲ ਬਣਾਉਣ ਵੇਲੇ ਲੋੜੀਂਦਾ ਹੈ।
ਇਕੱਲੇ ਇੱਕ ਸਪੇਸ ਜਾਂ ਕੌਮੇ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਇੱਕ ਸਿੰਟੈਕਸ ਗਲਤੀ ਹੋਵੇਗੀ।
empty_tuple = ()
print(empty_tuple)
print(type(empty_tuple))
# ()
# <class 'tuple'>
# empty_tuple_error =
# SyntaxError: invalid syntax
# empty_tuple_error = ,
# SyntaxError: invalid syntax
# empty_tuple_error = (,)
# SyntaxError: invalid syntax
ਖਾਲੀ ਟੂਪਲ ਵੀ ਬਿਨਾਂ ਕਿਸੇ ਆਰਗੂਮੈਂਟ ਦੇ tuple() ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ।
empty_tuple = tuple()
print(empty_tuple)
print(type(empty_tuple))
# ()
# <class 'tuple'>
ਫੰਕਸ਼ਨ ਆਰਗੂਮੈਂਟਾਂ ਵਿੱਚ ਟੂਪਲਸ
ਟੂਪਲ ਗੋਲ ਬਰੈਕਟਾਂ () ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਭਾਵੇਂ ਇੱਕ ਸਿੰਟੈਕਟਿਕ ਅਸਪਸ਼ਟਤਾ ਹੋਵੇ।
ਫੰਕਸ਼ਨ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਕਾਮਿਆਂ ਨਾਲ ਵੱਖ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਪਰ ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਗੋਲ ਬਰੈਕਟਾਂ () ਦੀ ਮੌਜੂਦਗੀ ਜਾਂ ਗੈਰਹਾਜ਼ਰੀ ਦੁਆਰਾ ਇਹ ਸਪਸ਼ਟ ਤੌਰ ‘ਤੇ ਦਰਸਾਉਣਾ ਜ਼ਰੂਰੀ ਹੁੰਦਾ ਹੈ ਕਿ ਕੀ ਫੰਕਸ਼ਨ ਇੱਕ ਟੂਪਲ ਹੈ ਜਾਂ ਨਹੀਂ।
ਬਰੈਕਟਾਂ ਤੋਂ ਬਿਨਾਂ (), ਹਰੇਕ ਮੁੱਲ ਨੂੰ ਹਰੇਕ ਆਰਗੂਮੈਂਟ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ; ਬਰੈਕਟਸ () ਦੇ ਨਾਲ, ਹਰੇਕ ਮੁੱਲ ਨੂੰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਦੇ ਟੁਪਲ ਵਜੋਂ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
def example(a, b):
print(a, type(a))
print(b, type(b))
example(0, 1)
# 0 <class 'int'>
# 1 <class 'int'>
# example((0, 1))
# TypeError: example() missing 1 required positional argument: 'b'
example((0, 1), 2)
# (0, 1) <class 'tuple'>
# 2 <class 'int'>
ਜੇਕਰ ਟੂਪਲ ਨੂੰ ਇੱਕ ਤਾਰੇ * ਨਾਲ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਟੂਪਲ ਦੇ ਤੱਤਾਂ ਦਾ ਵਿਸਤਾਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਪਾਸ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
example(*(0, 1))
# 0 <class 'int'>
# 1 <class 'int'>
ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ, ਅਗਲਾ ਲੇਖ ਦੇਖੋ।
