5. ਡਾਟਾ ਸੰਰਚਨਾਵਾਂ¶
ਇਹ ਅਧਿਆਇ ਉਹਨਾਂ ਕੁਝ ਵਿਸ਼ਿਆਂ ਨੂੰ ਹੋਰ ਵਿਸਥਾਰ ਨਾਲ ਸਮਝਾਉਂਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਬਾਰੇ ਤੁਸੀਂ ਪਹਿਲਾਂ ਸਿੱਖ ਚੁੱਕੇ ਹੋ, ਅਤੇ ਨਾਲ ਹੀ ਕੁਝ ਨਵੇਂ ਵਿਸ਼ੇ ਵੀ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ।
5.1. ਲਿਸਟਾਂ ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ¶
list ਡਾਟਾ ਕਿਸਮ ਵਿੱਚ ਕੁਝ ਹੋਰ ਵਿਧੀਆਂ ਵੀ ਹਨ। ਹੇਠਾਂ ਲਿਸਟ ਆਬਜੈਕਟ ਦੀਆਂ ਸਾਰੀਆਂ ਵਿਧੀਆਂ ਦਿੱਤੀਆਂ ਗਈਆਂ ਹਨ:
- list.append(value, /)
ਲਿਸਟ ਦੇ ਅੰਤ ਵਿੱਚ ਇੱਕ ਤੱਤ ਜੋੜਦਾ ਹੈ। ਇਹ
a[len(a):] = [x]ਦੇ ਸਮਾਨ ਹੈ।
- list.extend(iterable, /)
ਇਟਰੇਬਲ ਦੇ ਸਾਰੇ ਤੱਤ ਲਿਸਟ ਦੇ ਅੰਤ ਵਿੱਚ ਜੋੜ ਕੇ ਲਿਸਟ ਨੂੰ ਵਧਾਉਂਦਾ ਹੈ। ਇਹ
a[len(a):] = iterableਦੇ ਸਮਾਨ ਹੈ।
- list.insert(index, value, /)
ਦਿੱਤੀ ਗਈ ਸਥਿਤੀ 'ਤੇ ਇੱਕ ਤੱਤ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ। ਪਹਿਲਾ ਆਰਗੂਮੈਂਟ ਉਸ ਤੱਤ ਦਾ ਇੰਡੈਕਸ ਹੁੰਦਾ ਹੈ ਜਿਸ ਤੋਂ ਪਹਿਲਾਂ ਨਵਾਂ ਤੱਤ ਜੋੜਿਆ ਜਾਣਾ ਹੈ। ਇਸ ਲਈ
a.insert(0, x)ਲਿਸਟ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਤੱਤ ਜੋੜਦਾ ਹੈ, ਅਤੇa.insert(len(a), x)a.append(x)ਦੇ ਬਰਾਬਰ ਹੈ।
- list.remove(value, /)
ਲਿਸਟ ਵਿੱਚੋਂ ਉਸ ਪਹਿਲੇ ਤੱਤ ਨੂੰ ਹਟਾਉਂਦਾ ਹੈ ਜਿਸਦਾ ਮੁੱਲ value ਦੇ ਬਰਾਬਰ ਹੋਵੇ। ਜੇ ਅਜਿਹਾ ਕੋਈ ਤੱਤ ਮੌਜੂਦ ਨਾ ਹੋਵੇ ਤਾਂ
ValueErrorਉੱਠਾਈ ਜਾਂਦੀ ਹੈ।
- list.pop(index=-1, /)
ਲਿਸਟ ਵਿੱਚ ਦਿੱਤੀ ਗਈ ਸਥਿਤੀ ਉੱਤੇ ਮੌਜੂਦ ਤੱਤ ਨੂੰ ਹਟਾਉਂਦਾ ਹੈ ਅਤੇ ਉਸਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਜੇ ਕੋਈ ਇੰਡੈਕਸ ਨਹੀਂ ਦਿੱਤਾ ਜਾਂਦਾ, ਤਾਂ
a.pop()ਲਿਸਟ ਦੇ ਆਖਰੀ ਤੱਤ ਨੂੰ ਹਟਾ ਕੇ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਜੇ ਲਿਸਟ ਖਾਲੀ ਹੋਵੇ ਜਾਂ ਇੰਡੈਕਸ ਲਿਸਟ ਦੀ ਸੀਮਾ ਤੋਂ ਬਾਹਰ ਹੋਵੇ ਤਾਂIndexErrorਉੱਠਾਈ ਜਾਂਦੀ ਹੈ।
- list.clear()
ਲਿਸਟ ਵਿੱਚੋਂ ਸਾਰੇ ਤੱਤ ਹਟਾਉਂਦਾ ਹੈ। ਇਹ
del a[:]ਦੇ ਸਮਾਨ ਹੈ।
- list.index(value[, start[, stop]])
ਲਿਸਟ ਵਿੱਚ value ਦੀ ਪਹਿਲੀ ਮੌਜੂਦਗੀ ਦਾ ਸ਼ੂਨ੍ਯ-ਅਧਾਰਿਤ ਇੰਡੈਕਸ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਜੇ ਅਜਿਹਾ ਕੋਈ ਤੱਤ ਮੌਜੂਦ ਨਾ ਹੋਵੇ ਤਾਂ
ValueErrorਉੱਠਾਈ ਜਾਂਦੀ ਹੈ।ਵਿਕਲਪਿਕ ਆਰਗੂਮੈਂਟ start ਅਤੇ end ਨੂੰ ਸਲਾਈਸ ਨੋਟੇਸ਼ਨ ਵਾਂਗ ਸਮਝਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਹ ਖੋਜ ਨੂੰ ਲਿਸਟ ਦੇ ਕਿਸੇ ਖਾਸ ਉਪ-ਕ੍ਰਮ ਤੱਕ ਸੀਮਿਤ ਕਰਨ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ। ਵਾਪਸ ਕੀਤਾ ਗਿਆ ਇੰਡੈਕਸ start ਆਰਗੂਮੈਂਟ ਦੇ ਸਬੰਧ ਵਿੱਚ ਨਹੀਂ, ਸਗੋਂ ਪੂਰੇ ਕ੍ਰਮ ਦੀ ਸ਼ੁਰੂਆਤ ਦੇ ਸਬੰਧ ਵਿੱਚ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ।
- list.count(value, /)
ਲਿਸਟ ਵਿੱਚ value ਕਿੰਨੀ ਵਾਰ ਮੌਜੂਦ ਹੈ, ਉਸ ਦੀ ਗਿਣਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ।
- list.sort(*, key=None, reverse=False)
ਲਿਸਟ ਦੇ ਤੱਤਾਂ ਨੂੰ ਉਸੇ ਲਿਸਟ ਵਿੱਚ ਕ੍ਰਮਬੱਧ ਕਰਦਾ ਹੈ (ਸੋਰਟਿੰਗ ਨੂੰ ਅਨੁਕੂਲ ਕਰਨ ਲਈ ਆਰਗੂਮੈਂਟ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ; ਉਹਨਾਂ ਦੀ ਵਿਆਖਿਆ ਲਈ
sorted()ਵੇਖੋ)।
- list.reverse()
ਲਿਸਟ ਦੇ ਤੱਤਾਂ ਦਾ ਕ੍ਰਮ ਉਸੇ ਲਿਸਟ ਵਿੱਚ ਉਲਟ ਦਿੰਦਾ ਹੈ।
- list.copy()
ਲਿਸਟ ਦੀ ਇੱਕ ਸ਼ੈਲੋ ਕਾਪੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਹ
a[:]ਦੇ ਸਮਾਨ ਹੈ।
ਇੱਕ ਉਦਾਹਰਨ ਜੋ ਲਿਸਟ ਦੀਆਂ ਜ਼ਿਆਦਾਤਰ ਵਿਧੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ:
>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4) # Find next banana starting at position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
ਤੁਸੀਂ ਸ਼ਾਇਦ ਧਿਆਨ ਦਿੱਤਾ ਹੋਵੇ ਕਿ insert, remove ਜਾਂ sort ਵਰਗੀਆਂ ਵਿਧੀਆਂ, ਜੋ ਸਿਰਫ਼ ਲਿਸਟ ਨੂੰ ਬਦਲਦੀਆਂ ਹਨ, ਕੋਈ ਵਾਪਸੀ ਮੁੱਲ ਨਹੀਂ ਦਿਖਾਉਂਦੀਆਂ — ਇਹ ਮੂਲ ਰੂਪ ਵਿੱਚ None ਵਾਪਸ ਕਰਦੀਆਂ ਹਨ। [1] ਇਹ Python ਦੀਆਂ ਸਾਰੀਆਂ ਪਰਿਵਰਤਨਯੋਗ ਡਾਟਾ ਸੰਰਚਨਾਵਾਂ ਲਈ ਇੱਕ ਡਿਜ਼ਾਇਨ ਸਿਧਾਂਤ ਹੈ।
ਇੱਕ ਹੋਰ ਗੱਲ ਜੋ ਤੁਸੀਂ ਨੋਟ ਕਰ ਸਕਦੇ ਹੋ ਇਹ ਹੈ ਕਿ ਹਰ ਕਿਸਮ ਦੇ ਡਾਟਾ ਨੂੰ ਕ੍ਰਮਬੱਧ ਜਾਂ ਤੁਲਨਾ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ। ਉਦਾਹਰਨ ਲਈ, [None, 'hello', 10] ਨੂੰ ਸੋਰਟ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਕਿਉਂਕਿ ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਤੁਲਨਾ ਸਟਰਿੰਗਾਂ ਨਾਲ ਨਹੀਂ ਹੋ ਸਕਦੀ ਅਤੇ None ਦੀ ਤੁਲਨਾ ਹੋਰ ਕਿਸਮਾਂ ਨਾਲ ਨਹੀਂ ਹੋ ਸਕਦੀ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਕੁਝ ਕਿਸਮਾਂ ਲਈ ਕ੍ਰਮ ਸੰਬੰਧ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਹੁੰਦਾ। ਉਦਾਹਰਨ ਵਜੋਂ, 3+4j < 5+7j ਇੱਕ ਵੈਧ ਤੁਲਨਾ ਨਹੀਂ ਹੈ।
5.1.1. ਲਿਸਟਾਂ ਨੂੰ ਸਟੈਕ ਵਜੋਂ ਵਰਤਣਾ¶
ਲਿਸਟ ਦੀਆਂ ਵਿਧੀਆਂ ਲਿਸਟ ਨੂੰ ਸਟੈਕ ਵਜੋਂ ਵਰਤਣਾ ਬਹੁਤ ਆਸਾਨ ਬਣਾਉਂਦੀਆਂ ਹਨ, ਜਿੱਥੇ ਸਭ ਤੋਂ ਆਖ਼ਰ ਵਿੱਚ ਜੋੜਿਆ ਗਿਆ ਤੱਤ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ("last-in, first-out")। ਸਟੈਕ ਦੇ ਉੱਪਰਲੇ ਹਿੱਸੇ ਵਿੱਚ ਤੱਤ ਜੋੜਨ ਲਈ append() ਵਰਤੋ। ਸਟੈਕ ਦੇ ਉੱਪਰਲੇ ਹਿੱਸੇ ਤੋਂ ਤੱਤ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਬਿਨਾਂ ਸਪਸ਼ਟ ਇੰਡੈਕਸ ਦੇ pop() ਵਰਤੋ। ਉਦਾਹਰਨ ਲਈ:
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
5.1.2. ਲਿਸਟਾਂ ਨੂੰ ਕਤਾਰਾਂ ਵਜੋਂ ਵਰਤਣਾ¶
ਲਿਸਟ ਨੂੰ ਕਤਾਰ ਵਜੋਂ ਵਰਤਣਾ ਵੀ ਸੰਭਵ ਹੈ, ਜਿੱਥੇ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਜੋੜਿਆ ਗਿਆ ਤੱਤ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ("ਪਹਿਲਾਂ-ਅੰਦਰ, ਪਹਿਲਾਂ-ਬਾਹਰ"); ਹਾਲਾਂਕਿ, ਇਸ ਮਕਸਦ ਲਈ ਲਿਸਟਾਂ ਕੁਸ਼ਲ ਨਹੀਂ ਹਨ। ਲਿਸਟ ਦੇ ਅੰਤ ਤੋਂ ਤੱਤ ਜੋੜਨਾ ਅਤੇ ਹਟਾਉਣਾ ਤੇਜ਼ ਹੁੰਦਾ ਹੈ, ਪਰ ਲਿਸਟ ਦੇ ਸ਼ੁਰੂ ਤੋਂ ਤੱਤ ਜੋੜਨਾ ਜਾਂ ਹਟਾਉਣਾ ਹੌਲੀ ਹੁੰਦਾ ਹੈ (ਕਿਉਂਕਿ ਬਾਕੀ ਸਾਰੇ ਤੱਤਾਂ ਨੂੰ ਇੱਕ ਸਥਾਨ ਪਿੱਛੇ ਖਿਸਕਾਉਣਾ ਪੈਂਦਾ ਹੈ)। ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ Time complexity of operations on built-in types ਵੇਖੋ।
ਕਤਾਰ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ collections.deque ਵਰਤੋ, ਜਿਸ ਨੂੰ ਦੋਵੇਂ ਸਿਰਿਆਂ ਤੋਂ ਤੇਜ਼ append ਅਤੇ pop ਕਾਰਵਾਈਆਂ ਲਈ ਡਿਜ਼ਾਇਨ ਕੀਤਾ ਗਿਆ ਹੈ। ਉਦਾਹਰਨ ਲਈ:
>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry") # Terry arrives
>>> queue.append("Graham") # Graham arrives
>>> queue.popleft() # The first to arrive now leaves
'Eric'
>>> queue.popleft() # The second to arrive now leaves
'John'
>>> queue # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
5.1.3. ਲਿਸਟ ਕੰਪ੍ਰਿਹੈਂਸ਼ਨ¶
ਲਿਸਟ ਕੰਪ੍ਰਿਹੈਂਸ਼ਨ ਲਿਸਟਾਂ ਬਣਾਉਣ ਦਾ ਇੱਕ ਸੰਖੇਪ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ। ਇਸਦਾ ਆਮ ਵਰਤੋਂ ਨਵੀਆਂ ਲਿਸਟਾਂ ਬਣਾਉਣ ਲਈ ਹੁੰਦੀ ਹੈ ਜਿੱਥੇ ਹਰ ਤੱਤ ਕਿਸੇ ਹੋਰ ਕ੍ਰਮ ਜਾਂ ਇਟਰੇਬਲ ਦੇ ਹਰੇਕ ਮੈਂਬਰ ਉੱਤੇ ਕੀਤੀ ਗਈ ਕਾਰਵਾਈ ਦਾ ਨਤੀਜਾ ਹੁੰਦਾ ਹੈ, ਜਾਂ ਉਹਨਾਂ ਤੱਤਾਂ ਦਾ ਉਪ-ਕ੍ਰਮ ਬਣਾਉਣ ਲਈ ਜੋ ਕਿਸੇ ਨਿਰਧਾਰਤ ਸ਼ਰਤ ਨੂੰ ਪੂਰਾ ਕਰਦੇ ਹਨ।
ਉਦਾਹਰਨ ਲਈ, ਮੰਨ ਲਵੋ ਕਿ ਅਸੀਂ ਵਰਗਾਂ ਦੀ ਇੱਕ ਲਿਸਟ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹਾਂ:
>>> squares = []
>>> for x in range(10):
... squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
ਧਿਆਨ ਦਿਓ ਕਿ ਇਹ x ਨਾਮ ਦਾ ਇੱਕ ਵੇਰੀਏਬਲ ਬਣਾਉਂਦਾ ਹੈ (ਜਾਂ ਉਸਨੂੰ ਓਵਰਰਾਈਟ ਕਰਦਾ ਹੈ) ਜੋ ਲੂਪ ਮੁਕੰਮਲ ਹੋਣ ਤੋਂ ਬਾਅਦ ਵੀ ਮੌਜੂਦ ਰਹਿੰਦਾ ਹੈ। ਅਸੀਂ ਬਿਨਾਂ ਕਿਸੇ ਸਾਈਡ ਇਫੈਕਟ ਦੇ ਵਰਗਾਂ ਦੀ ਲਿਸਟ ਹੇਠਾਂ ਦਿੱਤੇ ਤਰੀਕੇ ਨਾਲ ਗਿਣ ਸਕਦੇ ਹਾਂ:
squares = list(map(lambda x: x**2, range(10)))
ਜਾਂ, ਇਸਦੇ ਸਮਾਨ:
squares = [x**2 for x in range(10)]
ਜੋ ਹੋਰ ਸੰਖੇਪ ਅਤੇ ਪੜ੍ਹਨ ਵਿੱਚ ਆਸਾਨ ਹੈ।
ਇੱਕ ਲਿਸਟ ਕੰਪ੍ਰਿਹੈਂਸ਼ਨ ਵਿੱਚ ਕੋਠਿਆਂ ਦੇ ਅੰਦਰ ਇੱਕ ਐਕਸਪ੍ਰੈਸ਼ਨ ਹੁੰਦੀ ਹੈ ਜਿਸ ਤੋਂ ਬਾਅਦ ਇੱਕ for ਕਲੌਜ਼ ਆਉਂਦੀ ਹੈ, ਅਤੇ ਫਿਰ ਸ਼ੂਨ੍ਯ ਜਾਂ ਇੱਕ ਤੋਂ ਵੱਧ for ਜਾਂ if ਕਲੌਜ਼ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਇਸ ਦਾ ਨਤੀਜਾ ਇੱਕ ਨਵੀਂ ਲਿਸਟ ਹੁੰਦੀ ਹੈ ਜੋ ਬਾਅਦ ਆਉਣ ਵਾਲੀਆਂ for ਅਤੇ if ਕਲੌਜ਼ਾਂ ਦੇ ਸੰਦਰਭ ਵਿੱਚ ਐਕਸਪ੍ਰੈਸ਼ਨ ਦਾ ਮੁਲਾਂਕਣ ਕਰਕੇ ਬਣਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇਹ listcomp ਦੋ ਲਿਸਟਾਂ ਦੇ ਤੱਤਾਂ ਨੂੰ ਜੋੜਦੀ ਹੈ ਜੇ ਉਹ ਇੱਕੋ ਜਿਹੇ ਨਾ ਹੋਣ:
>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
ਅਤੇ ਇਹ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਦੇ ਬਰਾਬਰ ਹੈ:
>>> combs = []
>>> for x in [1,2,3]:
... for y in [3,1,4]:
... if x != y:
... combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
ਧਿਆਨ ਦਿਓ ਕਿ ਦੋਵੇਂ ਕੋਡ ਟੁਕੜਿਆਂ ਵਿੱਚ for ਅਤੇ if ਸਟੇਟਮੈਂਟਾਂ ਦਾ ਕ੍ਰਮ ਇੱਕੋ ਜਿਹਾ ਹੈ।
ਜੇ ਐਕਸਪ੍ਰੈਸ਼ਨ ਇੱਕ ਟਿਊਪਲ ਹੈ (ਜਿਵੇਂ ਪਿਛਲੀ ਉਦਾਹਰਨ ਵਿੱਚ (x, y)), ਤਾਂ ਉਸਨੂੰ ਕੋਠਿਆਂ ਵਿੱਚ ਲਿਖਣਾ ਲਾਜ਼ਮੀ ਹੈ।
>>> vec = [-4, -2, 0, 2, 4]
>>> # create a new list with the values doubled
>>> [x*2 for x in vec]
[-8, -4, 0, 4, 8]
>>> # filter the list to exclude negative numbers
>>> [x for x in vec if x >= 0]
[0, 2, 4]
>>> # apply a function to all the elements
>>> [abs(x) for x in vec]
[4, 2, 0, 2, 4]
>>> # call a method on each element
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> # create a list of 2-tuples like (number, square)
>>> [(x, x**2) for x in range(6)]
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
>>> # the tuple must be parenthesized, otherwise an error is raised
>>> [x, x**2 for x in range(6)]
File "<stdin>", line 1
[x, x**2 for x in range(6)]
^^^^^^^
SyntaxError: did you forget parentheses around the comprehension target?
>>> # flatten a list using a listcomp with two 'for'
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
ਲਿਸਟ ਕੰਪ੍ਰਿਹੈਂਸ਼ਨ ਵਿੱਚ ਜਟਿਲ ਐਕਸਪ੍ਰੈਸ਼ਨ ਅਤੇ ਨੇਸਟਡ ਫੰਕਸ਼ਨ ਵੀ ਸ਼ਾਮਲ ਹੋ ਸਕਦੇ ਹਨ:
>>> from math import pi
>>> [str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']
5.1.4. ਨੇਸਟਡ ਲਿਸਟ ਕੰਪ੍ਰਿਹੈਂਸ਼ਨ¶
ਲਿਸਟ ਕੰਪ੍ਰਿਹੈਂਸ਼ਨ ਵਿੱਚ ਸ਼ੁਰੂਆਤੀ ਐਕਸਪ੍ਰੈਸ਼ਨ ਕੋਈ ਵੀ ਮਨਮਾਨੀ ਐਕਸਪ੍ਰੈਸ਼ਨ ਹੋ ਸਕਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਹੋਰ ਲਿਸਟ ਕੰਪ੍ਰਿਹੈਂਸ਼ਨ ਵੀ ਸ਼ਾਮਲ ਹੋ ਸਕਦੀ ਹੈ।
ਹੇਠਾਂ 3x4 ਮੈਟ੍ਰਿਕਸ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਹੈ ਜੋ ਲੰਬਾਈ 4 ਵਾਲੀਆਂ 3 ਲਿਸਟਾਂ ਦੀ ਲਿਸਟ ਵਜੋਂ ਲਾਗੂ ਕੀਤੀ ਗਈ ਹੈ:
>>> matrix = [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]
ਹੇਠਾਂ ਦਿੱਤੀ ਲਿਸਟ ਕੰਪ੍ਰਿਹੈਂਸ਼ਨ ਕਤਾਰਾਂ ਅਤੇ ਕਾਲਮਾਂ ਨੂੰ ਆਪਸ ਵਿੱਚ ਬਦਲ ਦੇਵੇਗੀ:
>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
ਜਿਵੇਂ ਅਸੀਂ ਪਿਛਲੇ ਭਾਗ ਵਿੱਚ ਵੇਖਿਆ ਸੀ, ਅੰਦਰਲੀ ਲਿਸਟ ਕੰਪ੍ਰਿਹੈਂਸ਼ਨ ਉਸਦੇ ਬਾਅਦ ਆਉਣ ਵਾਲੇ for ਦੇ ਸੰਦਰਭ ਵਿੱਚ ਮੁਲਾਂਕਿਤ ਹੁੰਦੀ ਹੈ, ਇਸ ਲਈ ਇਹ ਉਦਾਹਰਨ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਦੇ ਬਰਾਬਰ ਹੈ:
>>> transposed = []
>>> for i in range(4):
... transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
ਅਤੇ ਇਹ ਅੱਗੇ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਦੇ ਸਮਾਨ ਹੈ:
>>> transposed = []
>>> for i in range(4):
... # the following 3 lines implement the nested listcomp
... transposed_row = []
... for row in matrix:
... transposed_row.append(row[i])
... transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
ਵਿਹਾਰਿਕ ਤੌਰ 'ਤੇ, ਤੁਹਾਨੂੰ ਜਟਿਲ ਫਲੋ ਸਟੇਟਮੈਂਟਾਂ ਦੀ ਬਜਾਏ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਤਰਜੀਹ ਦੇਣੀ ਚਾਹੀਦੀ ਹੈ। ਇਸ ਵਰਤੋਂ ਲਈ zip() ਫੰਕਸ਼ਨ ਬਹੁਤ ਵਧੀਆ ਕੰਮ ਕਰੇਗਾ:
>>> list(zip(*matrix))
[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]
ਇਸ ਲਾਈਨ ਵਿੱਚ ਵਰਤੇ ਗਏ ਐਸਟਰਿਸਕ ਬਾਰੇ ਵੇਰਵੇ ਲਈ ਆਰਗਿਊਮੈਂਟ ਸੂਚੀਆਂ ਦਾ Unpacking ਵੇਖੋ।
5.1.5. ਲਿਸਟਾਂ ਅਤੇ ਲਿਸਟ ਕੰਪ੍ਰਿਹੈਂਸ਼ਨ ਵਿੱਚ ਅਨਪੈਕਿੰਗ¶
ਆਰਗਿਊਮੈਂਟ ਸੂਚੀਆਂ ਦਾ Unpacking ਭਾਗ ਵਿੱਚ * ਦੀ ਵਰਤੋਂ ਬਾਰੇ ਦੱਸਿਆ ਗਿਆ ਹੈ ਜੋ ਕਿਸੇ ਇਟਰੇਬਲ ਆਬਜੈਕਟ ਦੇ ਤੱਤਾਂ ਨੂੰ "ਅਨਪੈਕ" ਕਰਦਾ ਹੈ ਅਤੇ ਹਰ ਤੱਤ ਨੂੰ ਵੱਖਰੇ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਫੰਕਸ਼ਨ ਨੂੰ ਦਿੰਦਾ ਹੈ। ਅਨਪੈਕਿੰਗ ਹੋਰ ਸੰਦਰਭਾਂ ਵਿੱਚ ਵੀ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਉਦਾਹਰਨ ਲਈ ਲਿਸਟ ਬਣਾਉਣ ਵੇਲੇ। ਜਦੋਂ ਲਿਸਟ ਦੇ ਤੱਤ ਨਿਰਧਾਰਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਤਾਂ * ਨਾਲ ਸ਼ੁਰੂ ਕੀਤੀ ਐਕਸਪ੍ਰੈਸ਼ਨ ਦਾ ਨਤੀਜਾ ਅਨਪੈਕ ਹੋ ਜਾਂਦਾ ਹੈ ਅਤੇ ਉਸਦੇ ਸਾਰੇ ਤੱਤ ਬਣਾਈ ਜਾ ਰਹੀ ਲਿਸਟ ਵਿੱਚ ਜੋੜੇ ਜਾਂਦੇ ਹਨ:
>>> x = [1, 2, 3]
>>> [0, *x, 4, 5, 6]
[0, 1, 2, 3, 4, 5, 6]
ਇਹ ਸਿਰਫ਼ ਤਦ ਹੀ ਕੰਮ ਕਰਦਾ ਹੈ ਜਦੋਂ * ਤੋਂ ਬਾਅਦ ਵਾਲੀ ਐਕਸਪ੍ਰੈਸ਼ਨ ਕਿਸੇ ਇਟਰੇਬਲ ਆਬਜੈਕਟ ਵਿੱਚ ਮੁਲਾਂਕਿਤ ਹੋਵੇ। ਗੈਰ-ਇਟਰੇਬਲ ਆਬਜੈਕਟ ਨੂੰ ਅਨਪੈਕ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਇੱਕ ਅਪਵਾਦ ਪੈਦਾ ਕਰੇਗੀ:
>>> x = 1
>>> [0, *x, 2, 3, 4]
Traceback (most recent call last):
File "<python-input-1>", line 1, in <module>
[0, *x, 2, 3, 4]
TypeError: Value after * must be an iterable, not int
ਅਨਪੈਕਿੰਗ ਨੂੰ ਲਿਸਟ ਕੰਪ੍ਰਿਹੈਂਸ਼ਨ ਵਿੱਚ ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਤਾਂ ਜੋ ਮਨਚਾਹੀ ਗਿਣਤੀ ਦੇ ਇਟਰੇਬਲਾਂ ਦੇ ਜੋੜ ਨੂੰ ਦਰਸਾਉਣ ਵਾਲੀ ਨਵੀਂ ਲਿਸਟ ਬਣਾਈ ਜਾ ਸਕੇ:
>>> x = [[1, 2, 3], [4, 5, 6], [], [7], [8, 9]]
>>> [*element for element in x]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
ਧਿਆਨ ਦਿਓ ਕਿ ਇਸਦਾ ਪ੍ਰਭਾਵ ਇਹ ਹੈ ਕਿ x ਦਾ ਹਰ ਤੱਤ ਅਨਪੈਕ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਸਿਰਫ਼ ਲਿਸਟਾਂ ਲਈ ਨਹੀਂ, ਸਗੋਂ ਕਿਸੇ ਵੀ ਇਟਰੇਬਲ ਆਬਜੈਕਟ ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ:
>>> x = [[1, 2, 3], 'cat', {'spam': 'eggs'}]
>>> [*element for element in x]
[1, 2, 3, 'c', 'a', 't', 'spam']
ਪਰ ਜੇ x ਵਿੱਚ ਮੌਜੂਦ ਆਬਜੈਕਟ ਇਟਰੇਬਲ ਨਾ ਹੋਣ, ਤਾਂ ਇਹ ਐਕਸਪ੍ਰੈਸ਼ਨ ਮੁੜ ਇੱਕ ਅਪਵਾਦ ਪੈਦਾ ਕਰੇਗੀ।
5.2. del ਸਟੇਟਮੈਂਟ¶
ਲਿਸਟ ਵਿੱਚੋਂ ਕਿਸੇ ਤੱਤ ਨੂੰ ਉਸਦੇ ਮੁੱਲ ਦੀ ਬਜਾਏ ਉਸਦੇ ਇੰਡੈਕਸ ਰਾਹੀਂ ਹਟਾਉਣ ਦਾ ਇੱਕ ਤਰੀਕਾ ਹੈ: del ਸਟੇਟਮੈਂਟ। ਇਹ pop() ਵਿਧੀ ਤੋਂ ਵੱਖਰੀ ਹੈ ਕਿਉਂਕਿ ਉਹ ਇੱਕ ਮੁੱਲ ਵਾਪਸ ਕਰਦੀ ਹੈ। del ਸਟੇਟਮੈਂਟ ਨੂੰ ਲਿਸਟ ਵਿੱਚੋਂ ਸਲਾਈਸ ਹਟਾਉਣ ਜਾਂ ਪੂਰੀ ਲਿਸਟ ਖਾਲੀ ਕਰਨ ਲਈ ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ (ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਖਾਲੀ ਲਿਸਟ ਨੂੰ ਸਲਾਈਸ ਵਿੱਚ ਅਸਾਈਨ ਕਰਕੇ ਕੀਤਾ ਸੀ)। ਉਦਾਹਰਨ ਲਈ:
>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]
del ਨੂੰ ਪੂਰੇ ਵੇਰੀਏਬਲ ਮਿਟਾਉਣ ਲਈ ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ:
>>> del a
ਇਸ ਤੋਂ ਬਾਅਦ a ਨਾਮ ਦਾ ਹਵਾਲਾ ਦੇਣਾ ਇੱਕ ਗਲਤੀ ਹੋਵੇਗੀ (ਘੱਟੋ-ਘੱਟ ਤਦ ਤੱਕ ਜਦੋਂ ਤੱਕ ਇਸਨੂੰ ਕੋਈ ਨਵਾਂ ਮੁੱਲ ਅਸਾਈਨ ਨਾ ਕੀਤਾ ਜਾਵੇ)। ਅਸੀਂ ਬਾਅਦ ਵਿੱਚ del ਦੇ ਹੋਰ ਉਪਯੋਗ ਵੀ ਵੇਖਾਂਗੇ।
5.3. ਟਿਊਪਲ ਅਤੇ ਕ੍ਰਮ¶
ਅਸੀਂ ਵੇਖਿਆ ਕਿ ਲਿਸਟਾਂ ਅਤੇ ਸਟਰਿੰਗਾਂ ਵਿੱਚ ਕਈ ਸਾਂਝੇ ਗੁਣ ਹੁੰਦੇ ਹਨ, ਜਿਵੇਂ ਇੰਡੈਕਸਿੰਗ ਅਤੇ ਸਲਾਈਸਿੰਗ ਕਾਰਵਾਈਆਂ। ਇਹ sequence ਡਾਟਾ ਕਿਸਮਾਂ ਦੀਆਂ ਦੋ ਉਦਾਹਰਨਾਂ ਹਨ (ਵੇਖੋ Sequence Types --- list, tuple, range)। ਕਿਉਂਕਿ Python ਇੱਕ ਵਿਕਸਿਤ ਹੋ ਰਹੀ ਭਾਸ਼ਾ ਹੈ, ਇਸ ਵਿੱਚ ਹੋਰ sequence ਡਾਟਾ ਕਿਸਮਾਂ ਵੀ ਜੋੜੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ। ਇੱਕ ਹੋਰ ਮਿਆਰੀ sequence ਡਾਟਾ ਕਿਸਮ tuple ਹੈ।
ਇੱਕ ਟਿਊਪਲ ਕਾਮਿਆਂ ਨਾਲ ਵੱਖ ਕੀਤੇ ਗਏ ਕਈ ਮੁੱਲਾਂ ਤੋਂ ਬਣਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ:
>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
>>> u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
>>> # Tuples are immutable:
>>> t[0] = 88888
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> # but they can contain mutable objects:
>>> v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])
>>> # they support unpacking just like lists:
>>> x = [1, 2, 3]
>>> 0, *x, 4
(0, 1, 2, 3, 4)
ਜਿਵੇਂ ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ, ਆਉਟਪੁੱਟ ਵਿੱਚ ਟਿਊਪਲ ਹਮੇਸ਼ਾਂ ਕੋਠਿਆਂ ਵਿੱਚ ਦਿਖਾਏ ਜਾਂਦੇ ਹਨ ਤਾਂ ਜੋ ਨੇਸਟਡ ਟਿਊਪਲਾਂ ਦੀ ਸਹੀ ਵਿਆਖਿਆ ਹੋ ਸਕੇ। ਉਹਨਾਂ ਨੂੰ ਕੋਠਿਆਂ ਨਾਲ ਜਾਂ ਬਿਨਾਂ ਵੀ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਹਾਲਾਂਕਿ ਕਈ ਵਾਰ ਕੋਠਿਆਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ (ਜੇ ਟਿਊਪਲ ਕਿਸੇ ਵੱਡੀ ਐਕਸਪ੍ਰੈਸ਼ਨ ਦਾ ਹਿੱਸਾ ਹੋਵੇ)। ਟਿਊਪਲ ਦੇ ਵੱਖ-ਵੱਖ ਤੱਤਾਂ ਨੂੰ ਨਵਾਂ ਮੁੱਲ ਅਸਾਈਨ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ, ਪਰ ਅਜਿਹੇ ਟਿਊਪਲ ਬਣਾਏ ਜਾ ਸਕਦੇ ਹਨ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਲਿਸਟਾਂ ਵਰਗੇ ਪਰਿਵਰਤਨਯੋਗ ਆਬਜੈਕਟ ਹੋਣ।
ਹਾਲਾਂਕਿ ਟਿਊਪਲ ਸੂਚੀਆਂ ਵਰਗੇ ਲੱਗ ਸਕਦੇ ਹਨ, ਪਰ ਇਹ ਅਕਸਰ ਵੱਖ-ਵੱਖ ਸਥਿਤੀਆਂ ਅਤੇ ਵੱਖ-ਵੱਖ ਉਦੇਸ਼ਾਂ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ। ਟਿਊਪਲ immutable ਹੁੰਦੇ ਹਨ, ਅਤੇ ਆਮ ਤੌਰ 'ਤੇ ਇਹਨਾਂ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ ਤੱਤਾਂ ਦਾ ਇੱਕ ਮਿਸ਼ਰਤ ਕ੍ਰਮ ਹੁੰਦਾ ਹੈ, ਜਿਸ ਤੱਕ ਪਹੁੰਚ ਅਨਪੈਕਿੰਗ (ਇਸ ਭਾਗ ਵਿੱਚ ਬਾਅਦ ਵਿੱਚ ਵੇਖੋ) ਜਾਂ ਇੰਡੈਕਸਿੰਗ ਰਾਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ (ਜਾਂ namedtuples ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਐਟ੍ਰਿਬਿਊਟ ਰਾਹੀਂ)। ਸੂਚੀਆਂ mutable ਹੁੰਦੀਆਂ ਹਨ, ਅਤੇ ਉਹਨਾਂ ਦੇ ਤੱਤ ਆਮ ਤੌਰ 'ਤੇ ਇੱਕੋ ਕਿਸਮ ਦੇ ਹੁੰਦੇ ਹਨ ਅਤੇ ਸੂਚੀ 'ਤੇ ਇਟਰੇਟ ਕਰਕੇ ਉਹਨਾਂ ਤੱਕ ਪਹੁੰਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
ਇੱਕ ਵਿਸ਼ੇਸ਼ ਸਮੱਸਿਆ ਉਹ ਟਿਊਪਲਾਂ ਦੀ ਬਣਤਰ ਹੈ ਜਿਨ੍ਹਾਂ ਵਿੱਚ 0 ਜਾਂ 1 ਆਈਟਮ ਹੁੰਦੇ ਹਨ: ਇਨ੍ਹਾਂ ਨੂੰ ਸ਼ਾਮਿਲ ਕਰਨ ਲਈ ਸਿੰਟੈਕਸ ਵਿੱਚ ਕੁਝ ਵਾਧੂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹਨ। ਖਾਲੀ ਟਿਊਪਲਾਂ ਨੂੰ ਖਾਲੀ ਕੋਸ਼-ਜੋੜੀ ਨਾਲ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ; ਇੱਕ ਆਈਟਮ ਵਾਲਾ ਟਿਊਪਲ ਕਿਸੇ ਮੁੱਲ ਦੇ ਬਾਅਦ ਕਾਮਾ ਲਗਾ ਕੇ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ (ਇੱਕ ਇਕੱਲਾ ਮੁੱਲ ਕੋਸ਼-ਜੋੜੀ ਵਿੱਚ ਰੱਖਣਾ ਕਾਫ਼ੀ ਨਹੀਂ ਹੈ)। ਬਦਸੂਰਤ, ਪਰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ। ਉਦਾਹਰਨ ਵਜੋਂ:
>>> empty = ()
>>> singleton = 'hello', # <-- note trailing comma
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('hello',)
ਸਟੇਟਮੈਂਟ t = 12345, 54321, 'hello!' tuple packing ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਹੈ: ਮੁੱਲ 12345, 54321 ਅਤੇ 'hello!' ਨੂੰ ਇਕੱਠੇ ਇੱਕ ਟਿਊਪਲ ਵਿੱਚ ਪੈਕ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਸ ਦੀ ਉਲਟੀ ਕਾਰਵਾਈ ਵੀ ਸੰਭਵ ਹੈ:
>>> x, y, z = t
ਇਸਨੂੰ ਢੰਗ ਨਾਲ ਸੀਕਵੈਂਸ ਅਨਪੈਕਿੰਗ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਹ ਸੱਜੇ ਪਾਸੇ ਕਿਸੇ ਵੀ ਸੀਕਵੈਂਸ ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ। ਸੀਕਵੈਂਸ ਅਨਪੈਕਿੰਗ ਲਈ ਲੋੜ ਹੈ ਕਿ ਬਰਾਬਰ ਦੇ ਚਿੰਨ੍ਹ ਦੇ ਖੱਬੇ ਪਾਸੇ ਇੰਨੇ ਹੀ ਵੇਰੀਏਬਲ ਹੋਣ ਜਿੰਨੇ ਸੀਕਵੈਂਸ ਵਿੱਚ ਤੱਤ ਹਨ। ਧਿਆਨ ਦਿਓ ਕਿ ਮਲਟੀਪਲ ਅਸਾਈਨਮੈਂਟ ਅਸਲ ਵਿੱਚ ਸਿਰਫ਼ ਟੂਪਲ ਪੈਕਿੰਗ ਅਤੇ ਸੀਕਵੈਂਸ ਅਨਪੈਕਿੰਗ ਦਾ ਮਿਲਾਪ ਹੈ।
5.4. ਸੈੱਟ¶
Python ਵਿੱਚ sets ਲਈ ਵੀ ਇੱਕ ਡਾਟਾ ਕਿਸਮ ਸ਼ਾਮਲ ਹੈ। ਸੈੱਟ ਬਿਨਾਂ ਦੁਹਰਾਏ ਤੱਤਾਂ ਦਾ ਇੱਕ ਬੇਤਰਤੀਬ ਸੰਗ੍ਰਹਿ ਹੁੰਦਾ ਹੈ। ਇਸਦੇ ਮੁੱਢਲੇ ਉਪਯੋਗਾਂ ਵਿੱਚ ਮੈਂਬਰਸ਼ਿਪ ਜਾਂਚ ਅਤੇ ਦੁਹਰਾਏ ਹੋਏ ਤੱਤਾਂ ਨੂੰ ਹਟਾਉਣਾ ਸ਼ਾਮਲ ਹੈ। ਸੈੱਟ ਆਬਜੈਕਟ ਗਣਿਤੀ ਕਾਰਵਾਈਆਂ ਜਿਵੇਂ union, intersection, difference ਅਤੇ symmetric difference ਦਾ ਵੀ ਸਮਰਥਨ ਕਰਦੇ ਹਨ।
ਕਰਲੀ ਬ੍ਰੇਸਿਜ਼ ਜਾਂ set() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸੈੱਟ ਬਣਾਏ ਜਾ ਸਕਦੇ ਹਨ। ਧਿਆਨ ਦਿਓ: ਖਾਲੀ ਸੈੱਟ ਬਣਾਉਣ ਲਈ set() ਵਰਤਣਾ ਪੈਂਦਾ ਹੈ, {} ਨਹੀਂ; ਕਿਉਂਕਿ ਇੱਕ ਖਾਲੀ ਡਿਕਸ਼ਨਰੀ ਬਣਾਉਂਦਾ ਹੈ, ਜਿਸ ਬਾਰੇ ਅਸੀਂ ਅਗਲੇ ਭਾਗ ਵਿੱਚ ਚਰਚਾ ਕਰਾਂਗੇ।
ਕਿਉਂਕਿ ਸੈੱਟ ਬੇਤਰਤੀਬ ਹੁੰਦੇ ਹਨ, ਇਸ ਲਈ ਉਹਨਾਂ 'ਤੇ ਇਟਰੇਟ ਕਰਨ ਜਾਂ ਉਹਨਾਂ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਨ ਨਾਲ ਤੱਤ ਤੁਹਾਡੀ ਉਮੀਦ ਤੋਂ ਵੱਖਰੇ ਕ੍ਰਮ ਵਿੱਚ ਦਿਖਾਈ ਦੇ ਸਕਦੇ ਹਨ।
ਇੱਥੇ ਇੱਕ ਛੋਟਾ ਜਿਹਾ ਉਦਾਹਰਨ ਦਿੱਤਾ ਗਿਆ ਹੈ:
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # fast membership testing
True
>>> 'crabgrass' in basket
False
>>> # Demonstrate set operations on unique letters from two words
>>>
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b # letters in a or b or both
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # letters in both a and b
{'a', 'c'}
>>> a ^ b # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}
list comprehensions ਦੀ ਤਰ੍ਹਾਂ, set comprehensions ਦਾ ਵੀ ਸਮਰਥਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ unpacking ਵਾਲੀਆਂ comprehensions ਵੀ ਸ਼ਾਮਲ ਹਨ:
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
>>> fruits = [{'apple', 'avocado', 'apricot'}, {'banana', 'blueberry'}]
>>> {*fruit for fruit in fruits}
{'blueberry', 'banana', 'avocado', 'apple', 'apricot'}
5.5. ਡਿਕਸ਼ਨਰੀਆਂ¶
ਪਾਈਥਨ ਵਿੱਚ ਬਣਾਇਆ ਗਿਆ ਇੱਕ ਹੋਰ ਉਪਯੋਗੀ ਡੇਟਾ ਟਾਈਪ ਡਿਕਸ਼ਨਰੀ ਹੈ (ਦੇਖੋ Mapping types --- dict, frozendict)। ਡਿਕਸ਼ਨਰੀਆਂ ਨੂੰ ਕਈ ਵਾਰ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ "ਐਸੋਸੀਏਟਿਵ ਮੈਮੋਰੀਜ਼" ਜਾਂ "ਐਸੋਸੀਏਟਿਵ ਐਰੇਜ਼" ਵਜੋਂ ਵੀ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ। ਸੀਕਵੈਂਸਾਂ ਦੇ ਉਲਟ, ਜਿਨ੍ਹਾਂ ਦੀ ਇੰਡੈਕਸਿੰਗ ਨੰਬਰਾਂ ਦੀ ਰੇਂਜ ਨਾਲ ਹੁੰਦੀ ਹੈ, ਡਿਕਸ਼ਨਰੀਆਂ ਦੀ ਇੰਡੈਕਸਿੰਗ ਕੀਜ਼ ਨਾਲ ਹੁੰਦੀ ਹੈ, ਜੋ ਕਿਸੇ ਵੀ ਅਟੱਲ ਕਿਸਮ ਦੀ ਹੋ ਸਕਦੀ ਹੈ; ਸਟਰਿੰਗਾਂ ਅਤੇ ਨੰਬਰ ਹਮੇਸ਼ਾਂ ਕੀਜ਼ ਹੋ ਸਕਦੇ ਹਨ। ਟਿਊਪਲਾਂ ਨੂੰ ਕੀ ਵਜੋਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜੇਕਰ ਉਹਨਾਂ ਵਿੱਚ ਸਿਰਫ਼ ਸਟਰਿੰਗ, ਨੰਬਰ, ਜਾਂ ਟਿਊਪਲ ਹੀ ਹੋਣ; ਜੇਕਰ ਕਿਸੇ ਟਿਊਪਲ ਵਿੱਚ ਸਿੱਧੇ ਜਾਂ ਅਸਿੱਧੇ ਤੌਰ 'ਤੇ ਕੋਈ ਵੀ ਬਦਲਣਯੋਗ ਆਬਜੈਕਟ ਹੋਵੇ, ਤਾਂ ਇਸਨੂੰ ਕੀ ਵਜੋਂ ਨਹੀਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ। ਤੁਸੀਂ ਸੂਚੀਆਂ ਨੂੰ ਕੀ ਵਜੋਂ ਨਹੀਂ ਵਰਤ ਸਕਦੇ, ਕਿਉਂਕਿ ਸੂਚੀਆਂ ਨੂੰ ਇੰਡੈਕਸ ਅਸਾਈਨਮੈਂਟ, ਸਲਾਈਸ ਅਸਾਈਨਮੈਂਟ, ਜਾਂ append() ਅਤੇ extend() ਵਰਗੇ ਮੈਥਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਥਾਨ 'ਤੇ ਹੀ ਸੋਧਿਆ ਜਾ ਸਕਦਾ ਹੈ।
ਇੱਕ ਡਿਕਸ਼ਨਰੀ ਨੂੰ key: value ਜੋੜਿਆਂ ਦੇ ਇੱਕ ਸੈੱਟ ਵਜੋਂ ਸੋਚਣਾ ਸਭ ਤੋਂ ਵਧੀਆ ਹੈ, ਜਿਸ ਵਿੱਚ ਇਹ ਲੋੜ ਹੈ ਕਿ keys (ਇੱਕੋ ਡਿਕਸ਼ਨਰੀ ਵਿੱਚ) ਵਿਲੱਖਣ ਹੋਣ। ਬ੍ਰੈਸਿਜ਼ ਦੀ ਇੱਕ ਜੋੜੀ ਇੱਕ ਖਾਲੀ ਡਿਕਸ਼ਨਰੀ ਬਣਾਉਂਦੀ ਹੈ: {} । ਬ੍ਰੈਸਿਜ਼ ਦੇ ਅੰਦਰ ਕਾਮੇ ਨਾਲ ਵੱਖ-ਵੱਖ ਕੀਤੀ ਕੀ:ਮੁੱਲ ਜੋੜਿਆਂ ਦੀ ਸੂਚੀ ਰੱਖਣ ਨਾਲ ਡਿਕਸ਼ਨਰੀ ਵਿੱਚ ਸ਼ੁਰੂਆਤੀ ਕੀ:ਮੁੱਲ ਜੋੜੇ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ; ਇਹੀ ਤਰੀਕਾ ਆਉਟਪੁੱਟ 'ਤੇ ਡਿਕਸ਼ਨਰੀਆਂ ਲਿਖਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
ਡਿਕਸ਼ਨਰੀ ਉੱਤੇ ਮੁੱਖ ਕਾਰਵਾਈਆਂ ਵਿੱਚ ਕਿਸੇ ਕੀ ਨਾਲ ਮੁੱਲ ਸੰਭਾਲਣਾ ਅਤੇ ਕੀ ਦੇ ਆਧਾਰ ਉੱਤੇ ਉਸ ਮੁੱਲ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨਾ ਸ਼ਾਮਲ ਹੈ। del ਦੀ ਵਰਤੋਂ ਕਰਕੇ key:value ਜੋੜੇ ਨੂੰ ਮਿਟਾਇਆ ਵੀ ਜਾ ਸਕਦਾ ਹੈ। ਜੇ ਤੁਸੀਂ ਪਹਿਲਾਂ ਤੋਂ ਮੌਜੂਦ ਕੀ ਨਾਲ ਨਵਾਂ ਮੁੱਲ ਸੰਭਾਲਦੇ ਹੋ, ਤਾਂ ਪੁਰਾਣਾ ਮੁੱਲ ਭੁੱਲ ਜਾਂਦਾ ਹੈ।
ਜੇ ਤੁਸੀਂ subscripting (d[key]) ਰਾਹੀਂ ਇੱਕ ਗੈਰ-ਮੌਜੂਦ ਕੀ ਲਈ ਮੁੱਲ ਕੱਢਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋ, ਤਾਂ ਇਹ KeyError ਉਠਾਉਂਦਾ ਹੈ। ਸੰਭਾਵਤ ਤੌਰ 'ਤੇ ਗੈਰ-ਮੌਜੂਦ ਕੀ ਨੂੰ ਐਕਸੈਸ ਕਰਨ ਵੇਲੇ ਇਸ ਗਲਤੀ ਤੋਂ ਬਚਣ ਲਈ, ਇਸ ਦੀ ਥਾਂ get() ਵਿਧੀ ਵਰਤੋ, ਜੋ ਡਿਕਸ਼ਨਰੀ ਵਿੱਚ ਕੀ ਨਾ ਹੋਣ 'ਤੇ None (ਜਾਂ ਨਿਰਧਾਰਤ ਡਿਫਾਲਟ ਮੁੱਲ) ਵਾਪਸ ਕਰਦੀ ਹੈ।
ਡਿਕਸ਼ਨਰੀ ਉੱਤੇ list(d) ਚਲਾਉਣ ਨਾਲ ਉਸ ਵਿੱਚ ਵਰਤੀਆਂ ਗਈਆਂ ਸਾਰੀਆਂ keys ਦੀ ਲਿਸਟ insertion order ਵਿੱਚ ਮਿਲਦੀ ਹੈ (ਜੇ ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ ਕ੍ਰਮਬੱਧ ਦੇਖਣਾ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ sorted(d) ਵਰਤੋ)। ਕਿਸੇ ਇੱਕ ਕੀ ਦੀ ਮੌਜੂਦਗੀ ਦੀ ਜਾਂਚ ਲਈ in ਕੀਵਰਡ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
ਇੱਥੇ ਡਿਕਸ਼ਨਰੀ ਦੀ ਵਰਤੋਂ ਦਾ ਇੱਕ ਛੋਟਾ ਉਦਾਹਰਨ ਦਿੱਤਾ ਗਿਆ ਹੈ:
>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack']
4098
>>> tel['irv']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'irv'
>>> print(tel.get('irv'))
None
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127}
>>> list(tel)
['jack', 'guido', 'irv']
>>> sorted(tel)
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False
dict() constructor key-value ਜੋੜਿਆਂ ਦੇ ਕ੍ਰਮਾਂ ਤੋਂ ਸਿੱਧੇ ਡਿਕਸ਼ਨਰੀਆਂ ਬਣਾ ਸਕਦਾ ਹੈ:
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'guido': 4127, 'jack': 4098}
ਇਸ ਤੋਂ ਇਲਾਵਾ, dict comprehensions ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਨਚਾਹੀਆਂ key ਅਤੇ value ਐਕਸਪ੍ਰੈਸ਼ਨਾਂ ਤੋਂ ਡਿਕਸ਼ਨਰੀਆਂ ਬਣਾਈਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ:
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
ਡਿਕਸ਼ਨਰੀ unpacking (** ਰਾਹੀਂ) ਦੀ ਵਰਤੋਂ ਕਈ ਡਿਕਸ਼ਨਰੀਆਂ ਨੂੰ ਮਿਲਾਉਣ ਲਈ ਵੀ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ:
>>> odds = {i: i**2 for i in (1, 3, 5)}
>>> evens = {i: i**2 for i in (2, 4, 6)}
>>> {**odds, **evens}
{1: 1, 3: 9, 5: 25, 2: 4, 4: 16, 6: 36}
>>> all_values = [odds, evens, {0: 0}]
>>> {**i for i in all_values}
{1: 1, 3: 9, 5: 25, 2: 4, 4: 16, 6: 36, 0: 0}
ਜਦੋਂ keys ਸਧਾਰਣ ਸਟਰਿੰਗਾਂ ਹੋਣ, ਤਾਂ keyword arguments ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਜੋੜੇ ਨਿਰਧਾਰਤ ਕਰਨਾ ਕਈ ਵਾਰ ਹੋਰ ਆਸਾਨ ਹੁੰਦਾ ਹੈ:
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'guido': 4127, 'jack': 4098}
5.6. ਲੂਪਿੰਗ ਤਕਨੀਕਾਂ¶
ਡਿਕਸ਼ਨਰੀਆਂ ਉੱਤੇ ਲੂਪ ਚਲਾਉਂਦੇ ਸਮੇਂ, items() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀ ਅਤੇ ਉਸਦੇ ਸੰਬੰਧਿਤ ਮੁੱਲ ਨੂੰ ਇੱਕੋ ਸਮੇਂ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave
ਕਿਸੇ ਕ੍ਰਮ ਉੱਤੇ ਲੂਪ ਚਲਾਉਂਦੇ ਸਮੇਂ, enumerate() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਥਿਤੀ ਇੰਡੈਕਸ ਅਤੇ ਉਸਦੇ ਸੰਬੰਧਿਤ ਮੁੱਲ ਨੂੰ ਇੱਕੋ ਸਮੇਂ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
...
0 tic
1 tac
2 toe
ਦੋ ਜਾਂ ਵੱਧ ਕ੍ਰਮਾਂ ਉੱਤੇ ਇੱਕੋ ਸਮੇਂ ਲੂਪ ਚਲਾਉਣ ਲਈ, ਤੱਤਾਂ ਨੂੰ zip() ਫੰਕਸ਼ਨ ਨਾਲ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ।
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
ਕਿਸੇ ਕ੍ਰਮ ਉੱਤੇ ਉਲਟੇ ਕ੍ਰਮ ਵਿੱਚ ਲੂਪ ਚਲਾਉਣ ਲਈ, ਪਹਿਲਾਂ ਕ੍ਰਮ ਨੂੰ ਸਧਾਰਣ ਰੂਪ ਵਿੱਚ ਦਿਓ ਅਤੇ ਫਿਰ reversed() ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰੋ।
>>> for i in reversed(range(1, 10, 2)):
... print(i)
...
9
7
5
3
1
ਕਿਸੇ ਕ੍ਰਮ ਉੱਤੇ ਕ੍ਰਮਬੱਧ ਰੂਪ ਵਿੱਚ ਲੂਪ ਚਲਾਉਣ ਲਈ sorted() ਫੰਕਸ਼ਨ ਵਰਤੋ, ਜੋ ਮੂਲ ਕ੍ਰਮ ਨੂੰ ਬਿਨਾਂ ਬਦਲੇ ਇੱਕ ਨਵੀਂ ਕ੍ਰਮਬੱਧ ਲਿਸਟ ਵਾਪਸ ਕਰਦਾ ਹੈ।
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for i in sorted(basket):
... print(i)
...
apple
apple
banana
orange
orange
pear
ਕਿਸੇ ਕ੍ਰਮ ਉੱਤੇ set() ਦੀ ਵਰਤੋਂ ਕਰਨ ਨਾਲ ਦੁਹਰਾਏ ਤੱਤ ਹਟ ਜਾਂਦੇ ਹਨ। set() ਅਤੇ sorted() ਨੂੰ ਇਕੱਠੇ ਵਰਤਣਾ ਕ੍ਰਮ ਦੇ ਵਿਲੱਖਣ ਤੱਤਾਂ ਉੱਤੇ ਕ੍ਰਮਬੱਧ ਰੂਪ ਵਿੱਚ ਲੂਪ ਚਲਾਉਣ ਦਾ ਇੱਕ ਆਮ Python ਤਰੀਕਾ ਹੈ।
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear
ਕਈ ਵਾਰ ਲੂਪ ਦੌਰਾਨ ਲਿਸਟ ਨੂੰ ਬਦਲਣ ਦੀ ਇੱਛਾ ਹੋ ਸਕਦੀ ਹੈ; ਹਾਲਾਂਕਿ, ਇਸਦੀ ਬਜਾਏ ਨਵੀਂ ਲਿਸਟ ਬਣਾਉਣਾ ਅਕਸਰ ਹੋਰ ਆਸਾਨ ਅਤੇ ਸੁਰੱਖਿਅਤ ਹੁੰਦਾ ਹੈ।
>>> import math
>>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
>>> filtered_data = []
>>> for value in raw_data:
... if not math.isnan(value):
... filtered_data.append(value)
...
>>> filtered_data
[56.2, 51.7, 55.3, 52.5, 47.8]
5.7. ਸ਼ਰਤਾਂ ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ¶
while ਅਤੇ if ਸਟੇਟਮੈਂਟਾਂ ਵਿੱਚ ਵਰਤੀਆਂ ਜਾਣ ਵਾਲੀਆਂ ਸ਼ਰਤਾਂ ਵਿੱਚ ਕੇਵਲ ਤੁਲਨਾਵਾਂ ਹੀ ਨਹੀਂ, ਸਗੋਂ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੇ ਓਪਰੇਟਰ ਸ਼ਾਮਲ ਹੋ ਸਕਦੇ ਹਨ।
ਤੁਲਨਾ ਓਪਰੇਟਰ in ਅਤੇ not in ਮੈਂਬਰਸ਼ਿਪ ਟੈਸਟ ਹੁੰਦੇ ਹਨ ਜੋ ਇਹ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਨ ਕਿ ਕੋਈ ਮੁੱਲ ਕਿਸੇ ਕੰਟੇਨਰ ਵਿੱਚ ਹੈ (ਜਾਂ ਨਹੀਂ)। is ਅਤੇ is not ਓਪਰੇਟਰ ਇਹ ਤੁਲਨਾ ਕਰਦੇ ਹਨ ਕਿ ਦੋ ਓਬਜੈਕਟ ਅਸਲ ਵਿੱਚ ਇੱਕੋ ਹੀ ਓਬਜੈਕਟ ਹਨ ਜਾਂ ਨਹੀਂ। ਸਾਰੇ ਤੁਲਨਾ ਓਪਰੇਟਰਾਂ ਦੀ ਤਰਜੀਹ ਇਕੋ ਜਿਹੀ ਹੁੰਦੀ ਹੈ, ਜੋ ਸਾਰੇ ਸੰਖਿਆਤਮਕ ਓਪਰੇਟਰਾਂ ਨਾਲੋਂ ਘੱਟ ਹੁੰਦੀ ਹੈ।
ਤੁਲਨਾਵਾਂ ਨੂੰ ਲੜੀਵਾਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, a < b == c ਇਹ ਜਾਂਚਦਾ ਹੈ ਕਿ a , b ਤੋਂ ਛੋਟਾ ਹੈ ਅਤੇ ਨਾਲ ਹੀ b , c ਦੇ ਬਰਾਬਰ ਹੈ।
ਤੁਲਨਾਵਾਂ ਨੂੰ Boolean ਓਪਰੇਟਰ and ਅਤੇ or ਨਾਲ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਅਤੇ ਕਿਸੇ ਤੁਲਨਾ (ਜਾਂ ਹੋਰ Boolean ਐਕਸਪ੍ਰੈਸ਼ਨ) ਦੇ ਨਤੀਜੇ ਨੂੰ not ਨਾਲ ਨਕਾਰਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਨ੍ਹਾਂ ਦੀ ਪ੍ਰਾਥਮਿਕਤਾ ਤੁਲਨਾ ਓਪਰੇਟਰਾਂ ਨਾਲੋਂ ਘੱਟ ਹੁੰਦੀ ਹੈ; ਇਨ੍ਹਾਂ ਵਿੱਚ not ਦੀ ਸਭ ਤੋਂ ਵੱਧ ਅਤੇ or ਦੀ ਸਭ ਤੋਂ ਘੱਟ ਪ੍ਰਾਥਮਿਕਤਾ ਹੁੰਦੀ ਹੈ। ਇਸ ਲਈ A and not B or C , (A and (not B)) or C ਦੇ ਬਰਾਬਰ ਹੈ। ਹਮੇਸ਼ਾਂ ਦੀ ਤਰ੍ਹਾਂ, ਚਾਹੀਦੀ ਰਚਨਾ ਦਰਸਾਉਣ ਲਈ ਕੋਠਿਆਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।
Boolean ਓਪਰੇਟਰ and ਅਤੇ or ਨੂੰ short-circuit ਓਪਰੇਟਰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਇਨ੍ਹਾਂ ਦੇ ਆਰਗੂਮੈਂਟ ਖੱਬੇ ਤੋਂ ਸੱਜੇ ਵੱਲ ਮੁਲਾਂਕਿਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਜਿਵੇਂ ਹੀ ਨਤੀਜਾ ਨਿਰਧਾਰਤ ਹੋ ਜਾਂਦਾ ਹੈ, ਮੁਲਾਂਕਣ ਰੁਕ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਜੇ A ਅਤੇ C ਸਹੀ ਹੋਣ ਪਰ B ਗਲਤ ਹੋਵੇ, ਤਾਂ A and B and C ਵਿੱਚ C ਦਾ ਮੁਲਾਂਕਣ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ। ਜਦੋਂ ਇਹ Boolean ਦੀ ਬਜਾਏ ਇੱਕ ਆਮ ਮੁੱਲ ਵਜੋਂ ਵਰਤੇ ਜਾਂਦੇ ਹਨ, ਤਾਂ short-circuit ਓਪਰੇਟਰ ਦਾ ਵਾਪਸੀ ਮੁੱਲ ਆਖਰੀ ਮੁਲਾਂਕਿਤ ਆਰਗੂਮੈਂਟ ਹੁੰਦਾ ਹੈ।
ਕਿਸੇ ਤੁਲਨਾ ਜਾਂ ਹੋਰ Boolean ਐਕਸਪ੍ਰੈਸ਼ਨ ਦੇ ਨਤੀਜੇ ਨੂੰ ਇੱਕ ਵੇਰੀਏਬਲ ਵਿੱਚ ਅਸਾਈਨ ਕਰਨਾ ਸੰਭਵ ਹੈ। ਉਦਾਹਰਨ ਲਈ,
>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'
>>> non_null = string1 or string2 or string3
>>> non_null
'Trondheim'
ਧਿਆਨ ਦਿਓ ਕਿ Python ਵਿੱਚ, C ਦੇ ਉਲਟ, ਐਕਸਪ੍ਰੈਸ਼ਨਾਂ ਦੇ ਅੰਦਰ ਅਸਾਈਨਮੈਂਟ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ walrus operator := ਨਾਲ ਕਰਨੀ ਪੈਂਦੀ ਹੈ। ਇਸ ਨਾਲ C ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਆਉਣ ਵਾਲੀ ਇੱਕ ਆਮ ਸਮੱਸਿਆ ਤੋਂ ਬਚਿਆ ਜਾਂਦਾ ਹੈ, ਜਿੱਥੇ == ਦੀ ਥਾਂ ਗਲਤੀ ਨਾਲ = ਲਿਖ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।
5.8. ਕ੍ਰਮਾਂ ਅਤੇ ਹੋਰ ਕਿਸਮਾਂ ਦੀ ਤੁਲਨਾ¶
ਸੀਕਵੈਂਸ ਆਬਜੈਕਟ ਆਮ ਤੌਰ 'ਤੇ ਇੱਕੋ ਕਿਸਮ ਦੇ ਹੋਰ ਆਬਜੈਕਟਾਂ ਨਾਲ ਤੁਲਨਾ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਇਹ ਤੁਲਨਾ ਲੈਕਸੀਕੋਗ੍ਰਾਫਿਕਲ ਕ੍ਰਮਬੱਧਤਾ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ: ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਪਹਿਲੇ ਦੋ ਆਈਟਮਾਂ ਦੀ ਤੁਲਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਜੇ ਉਹ ਵੱਖਰੇ ਹੁੰਦੇ ਹਨ ਤਾਂ ਇਹ ਤੁਲਨਾ ਦਾ ਨਤੀਜਾ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ; ਜੇ ਉਹ ਬਰਾਬਰ ਹੁੰਦੇ ਹਨ, ਤਾਂ ਅਗਲੇ ਦੋ ਆਈਟਮਾਂ ਦੀ ਤੁਲਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਇਸੇ ਤਰ੍ਹਾਂ ਜਦ ਤੱਕ ਕਿਸੇ ਵੀ ਸੀਕਵੈਂਸ ਦੇ ਆਈਟਮ ਬਾਕੀ ਨਹੀਂ ਰਹਿ ਜਾਂਦੇ। ਜੇ ਤੁਲਨਾ ਲਈ ਰੱਖੀਆਂ ਦੋ ਆਈਟਮ ਖੁਦ ਇੱਕੋ ਕਿਸਮ ਦੀਆਂ ਸੀਕਵੈਂਸਾਂ ਹੋਣ, ਤਾਂ ਲੈਕਸੀਕੋਗ੍ਰਾਫਿਕਲ ਤੁਲਨਾ ਰਿਕਾਰਸੀਵ ਤਰੀਕੇ ਨਾਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਜੇ ਦੋਹਾਂ ਸੀਕਵੈਂਸਾਂ ਦੀਆਂ ਸਾਰੀਆਂ ਆਈਟਮਾਂ ਦੀ ਤੁਲਨਾ ਬਰਾਬਰ ਹੋਵੇ, ਤਾਂ ਦੋਹਾਂ ਸੀਕਵੈਂਸਾਂ ਨੂੰ ਬਰਾਬਰ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਜੇ ਇੱਕ ਸੀਕਵੈਂਸ ਦੂਜੇ ਦਾ ਸ਼ੁਰੂਆਤੀ ਉਪ-ਸੀਕਵੈਂਸ ਹੋਵੇ, ਤਾਂ ਛੋਟੀ ਸੀਕਵੈਂਸ ਛੋਟੀ (ਘੱਟ) ਮੰਨੀ ਜਾਂਦੀ ਹੈ। ਸਟਰਿੰਗਾਂ ਲਈ ਲੈਕਸੀਕੋਗ੍ਰਾਫੀਕਲ ਕ੍ਰਮਬੱਧਤਾ ਵਿਅਕਤੀਗਤ ਅੱਖਰਾਂ ਨੂੰ ਕ੍ਰਮਬੱਧ ਕਰਨ ਲਈ ਯੂਨੀਕੋਡ ਕੋਡ ਪੁਆਇੰਟ ਨੰਬਰ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ। ਇੱਕੋ ਕਿਸਮ ਦੀਆਂ ਲੜੀਆਂ ਵਿਚਕਾਰ ਤੁਲਨਾ ਦੀਆਂ ਕੁਝ ਉਦਾਹਰਣਾਂ:
(1, 2, 3) < (1, 2, 4)
[1, 2, 3] < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4) < (1, 2, 4)
(1, 2) < (1, 2, -1)
(1, 2, 3) == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)
ਧਿਆਨ ਦਿਓ ਕਿ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ ਆਬਜੈਕਟਾਂ ਦੀ 2 < ਜਾਂ 3 > ਨਾਲ ਤੁਲਨਾ ਤਦੋਂ ਵੈਧ ਹੁੰਦੀ ਹੈ ਜੇ ਉਹਨਾਂ ਕੋਲ ਉਚਿਤ ਤੁਲਨਾ ਵਿਧੀਆਂ ਹੋਣ। ਉਦਾਹਰਨ ਲਈ, ਮਿਲੀਆਂ-ਜੁਲੀਆਂ ਸੰਖਿਆਤਮਕ ਕਿਸਮਾਂ ਦੀ ਤੁਲਨਾ ਉਹਨਾਂ ਦੇ ਸੰਖਿਆਤਮਕ ਮੁੱਲ ਅਨੁਸਾਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਇਸ ਲਈ 0 ਅਤੇ 0.0 ਬਰਾਬਰ ਮੰਨੇ ਜਾਂਦੇ ਹਨ। ਨਹੀਂ ਤਾਂ, ਮਨਮਾਨਾ ਕ੍ਰਮ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਬਜਾਏ, ਇੰਟਰਪ੍ਰੀਟਰ TypeError ਅਪਵਾਦ ਉੱਠਾਏਗਾ।
ਫੁੱਟਨੋਟ