ਪਾਈਥਨ ਦੇ ਕਾਊਂਟਰ ਨਾਲ ਸੂਚੀ ਵਿੱਚ ਹਰੇਕ ਤੱਤ ਦੀਆਂ ਘਟਨਾਵਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਗਿਣਨਾ

ਪਾਈਥਨ ਵਿੱਚ, ਇੱਕ ਸੂਚੀ ਜਾਂ ਟੂਪਲ ਵਿੱਚ ਸਾਰੇ ਤੱਤਾਂ ਦੀ ਸੰਖਿਆ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ len() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਅਤੇ ਹਰੇਕ ਤੱਤ ਦੀ ਸੰਖਿਆ (ਹਰੇਕ ਤੱਤ ਦੀਆਂ ਘਟਨਾਵਾਂ ਦੀ ਸੰਖਿਆ) ਕਾਉਂਟ() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। .

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਪਾਇਥਨ ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ ਸੰਗ੍ਰਹਿ ਦੀ ਕਾਊਂਟਰ ਕਲਾਸ ਨੂੰ ਘਟਨਾਵਾਂ ਦੀ ਸੰਖਿਆ ਦੇ ਕ੍ਰਮ ਵਿੱਚ ਤੱਤ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਇਸ ਭਾਗ ਵਿੱਚ, ਅਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਬਾਰੇ ਚਰਚਾ ਕਰਾਂਗੇ

• ਤੱਤਾਂ ਦੀ ਕੁੱਲ ਗਿਣਤੀ ਗਿਣੋ:len()
• ਹਰੇਕ ਤੱਤ ਦੀ ਗਿਣਤੀ ਗਿਣੋ (ਹਰੇਕ ਤੱਤ ਦੀਆਂ ਘਟਨਾਵਾਂ ਦੀ ਗਿਣਤੀ):count()
• ਵਰਤੋਂ।collections.Counter
• ਤੱਤ ਮੌਜੂਦਗੀ ਦੀ ਬਾਰੰਬਾਰਤਾ ਦੇ ਕ੍ਰਮ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ:most_common()
• ਗੈਰ-ਓਵਰਲੈਪਿੰਗ ਤੱਤਾਂ (ਵਿਲੱਖਣ ਤੱਤ) ਦੀ ਸੰਖਿਆ (ਕਿਸਮ) ਦੀ ਗਿਣਤੀ ਕਰੋ।
• ਸ਼ਰਤ ਨੂੰ ਸੰਤੁਸ਼ਟ ਕਰਨ ਵਾਲੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਗਿਣੋ।

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇੱਕ ਠੋਸ ਉਦਾਹਰਨ ਵਜੋਂ, ਹੇਠਾਂ ਦਿੱਤੇ ਨਮੂਨੇ ਕੋਡ ਨਾਲ ਸਮਝਾਇਆ ਗਿਆ ਹੈ।

• ਇੱਕ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਕਿਸੇ ਸ਼ਬਦ ਦੀਆਂ ਘਟਨਾਵਾਂ ਦੀ ਗਿਣਤੀ ਗਿਣਦਾ ਹੈ।
• ਇੱਕ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਇੱਕ ਅੱਖਰ ਦੀਆਂ ਘਟਨਾਵਾਂ ਦੀ ਗਿਣਤੀ ਗਿਣੋ।

ਨਮੂਨਾ ਇੱਕ ਸੂਚੀ ਹੈ, ਪਰ ਉਹੀ ਪ੍ਰੋਸੈਸਿੰਗ ਟੂਪਲਾਂ ਨਾਲ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ.

ਤੱਤਾਂ ਦੀ ਕੁੱਲ ਗਿਣਤੀ ਗਿਣੋ: len()

ਇੱਕ ਸੂਚੀ ਜਾਂ ਟੂਪਲ ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਕੁੱਲ ਗਿਣਤੀ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ, ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ len() ਦੀ ਵਰਤੋਂ ਕਰੋ।

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']

print(len(l))
# 7

ਹਰੇਕ ਤੱਤ ਦੀ ਗਿਣਤੀ (ਹਰੇਕ ਤੱਤ ਦੀਆਂ ਘਟਨਾਵਾਂ ਦੀ ਗਿਣਤੀ): ਗਿਣਤੀ () ਵਿਧੀ

ਹਰੇਕ ਤੱਤ ਦੀ ਗਿਣਤੀ (ਹਰੇਕ ਤੱਤ ਦੀਆਂ ਘਟਨਾਵਾਂ ਦੀ ਗਿਣਤੀ) ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ, ਸੂਚੀਆਂ, ਟੂਪਲਾਂ ਆਦਿ ਲਈ ਗਿਣਤੀ () ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।

• Common Sequence Operations — Built-in Types — Python 3.10.0 Documentation

ਜੇਕਰ ਇੱਕ ਮੁੱਲ ਜੋ ਇੱਕ ਤੱਤ ਦੇ ਰੂਪ ਵਿੱਚ ਮੌਜੂਦ ਨਹੀਂ ਹੈ, ਨੂੰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, 0 ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']

print(l.count('a'))
# 4

print(l.count('b'))
# 1

print(l.count('c'))
# 2

print(l.count('d'))
# 0

ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਵਾਰ ਵਿੱਚ ਹਰੇਕ ਤੱਤ ਦੀਆਂ ਘਟਨਾਵਾਂ ਦੀ ਗਿਣਤੀ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਹੇਠਾਂ ਦਿੱਤਾ ਸੰਗ੍ਰਹਿ. ਕਾਊਂਟਰ ਲਾਭਦਾਇਕ ਹੈ।

ਸੰਗ੍ਰਹਿ. ਕਾਊਂਟਰ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ

ਪਾਈਥਨ ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ ਸੰਗ੍ਰਹਿ ਵਿੱਚ ਇੱਕ ਕਾਊਂਟਰ ਕਲਾਸ ਹੈ।

• collections – Counter — Container datatypes — Python 3.10.0 Documentation

Counter() ਡਿਕਸ਼ਨਰੀ ਟਾਈਪ ਡਿਕਟ ਦਾ ਇੱਕ ਉਪ-ਕਲਾਸ ਹੈ, ਜਿਸ ਵਿੱਚ ਕੁੰਜੀਆਂ ਦੇ ਰੂਪ ਵਿੱਚ ਤੱਤਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਡੇਟਾ ਅਤੇ ਮੁੱਲਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਮੌਜੂਦਗੀ ਹੁੰਦੀ ਹੈ।

import collections

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']

c = collections.Counter(l)
print(c)
# Counter({'a': 4, 'c': 2, 'b': 1})

print(type(c))
# <class 'collections.Counter'>

print(issubclass(type(c), dict))
# True

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

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

ਤੁਸੀਂ ਸ਼ਬਦਕੋਸ਼ ਕਿਸਮ ਦੇ ਢੰਗਾਂ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ ਜਿਵੇਂ ਕਿ ਕੀ(), ਮੁੱਲ(), ਆਈਟਮਾਂ(), ਆਦਿ।

print(c.keys())
# dict_keys(['a', 'b', 'c'])

print(c.values())
# dict_values([4, 1, 2])

print(c.items())
# dict_items([('a', 4), ('b', 1), ('c', 2)])

ਇਹ ਵਿਧੀਆਂ dict_keys ਆਦਿ ਦੀਆਂ ਵਸਤੂਆਂ ਨੂੰ ਵਾਪਸ ਕਰਦੀਆਂ ਹਨ। ਇਹਨਾਂ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜਿਵੇਂ ਤੁਸੀਂ ਸਟੇਟਮੈਂਟ ਲਈ ਇੱਕ ਚਲਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ। ਜੇਕਰ ਤੁਸੀਂ ਇਸਨੂੰ ਸੂਚੀ ਵਿੱਚ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਸੂਚੀ() ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਦਿੱਖ ਦੀ ਬਾਰੰਬਾਰਤਾ ਦੇ ਕ੍ਰਮ ਵਿੱਚ ਤੱਤ ਪ੍ਰਾਪਤ ਕਰਨਾ: most_common() ਵਿਧੀ

ਕਾਊਂਟਰ ਕੋਲ most_common() ਵਿਧੀ ਹੈ, ਜੋ ਕਿ ਰੂਪ (ਤੱਤ, ਮੌਜੂਦਗੀ ਦੀ ਸੰਖਿਆ) ਦੇ ਟੂਪਲਾਂ ਦੀ ਸੂਚੀ ਵਾਪਸ ਕਰਦੀ ਹੈ ਜੋ ਕਿ ਘਟਨਾਵਾਂ ਦੀ ਸੰਖਿਆ ਦੁਆਰਾ ਕ੍ਰਮਬੱਧ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

print(c.most_common())
# [('a', 4), ('c', 2), ('b', 1)]

ਘਟਨਾਵਾਂ ਦੀ ਸਭ ਤੋਂ ਵੱਧ ਸੰਖਿਆ ਵਾਲਾ ਤੱਤ ਇੱਕ ਸੂਚਕਾਂਕ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਕੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਸਭ ਤੋਂ ਵੱਧ ਸੰਖਿਆ ਲਈ [0] ਅਤੇ ਸਭ ਤੋਂ ਘੱਟ ਸੰਖਿਆ ਲਈ [-1]। ਜੇਕਰ ਤੁਸੀਂ ਸਿਰਫ਼ ਤੱਤ ਜਾਂ ਸਿਰਫ਼ ਘਟਨਾਵਾਂ ਦੀ ਗਿਣਤੀ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਸੂਚਕਾਂਕ ਨੂੰ ਹੋਰ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ।

print(c.most_common()[0])
# ('a', 4)

print(c.most_common()[-1])
# ('b', 1)

print(c.most_common()[0][0])
# a

print(c.most_common()[0][1])
# 4

ਜੇਕਰ ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ ਘਟਨਾਵਾਂ ਦੀ ਘੱਟਦੀ ਗਿਣਤੀ ਦੇ ਕ੍ਰਮ ਵਿੱਚ ਛਾਂਟਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ -1 ਤੇ ਸੈਟ ਕੀਤੇ ਵਾਧੇ ਦੇ ਨਾਲ ਟੁਕੜੇ ਦੀ ਵਰਤੋਂ ਕਰੋ।

print(c.most_common()[::-1])
# [('b', 1), ('c', 2), ('a', 4)]

ਜੇਕਰ ਆਰਗੂਮੈਂਟ n ਨੂੰ most_common() ਵਿਧੀ ਲਈ ਨਿਸ਼ਚਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਸਿਰਫ n ਤੱਤ ਹੀ ਵਾਪਸ ਕੀਤੇ ਜਾਣਗੇ ਜਿਨ੍ਹਾਂ ਦੀ ਸਭ ਤੋਂ ਵੱਧ ਸੰਖਿਆਵਾਂ ਹਨ। ਜੇਕਰ ਇਸਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਸਾਰੇ ਤੱਤ।

print(c.most_common(2))
# [('a', 4), ('c', 2)]

ਜੇਕਰ ਤੁਸੀਂ (ਤੱਤ, ਮੌਜੂਦਗੀ ਦੀ ਗਿਣਤੀ) ਦੇ ਇੱਕ ਟੁਪਲ ਦੀ ਬਜਾਏ, ਘਟਨਾਵਾਂ ਦੀ ਸੰਖਿਆ ਦੁਆਰਾ ਕ੍ਰਮਬੱਧ ਤੱਤਾਂ/ਮੌਕਿਆਂ ਦੀ ਇੱਕ ਵੱਖਰੀ ਸੂਚੀ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇਸਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਅਨੁਸਾਰ ਵਿਗਾੜ ਸਕਦੇ ਹੋ

values, counts = zip(*c.most_common())

print(values)
# ('a', 'c', 'b')

print(counts)
# (4, 2, 1)

ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ zip() ਦੀ ਵਰਤੋਂ ਦੋ-ਅਯਾਮੀ ਸੂਚੀ (ਇਸ ਕੇਸ ਵਿੱਚ, ਟੂਪਲਾਂ ਦੀ ਸੂਚੀ) ਨੂੰ ਟ੍ਰਾਂਸਪੋਜ਼ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਫਿਰ ਇਸਨੂੰ ਅਨਪੈਕ ਅਤੇ ਐਕਸਟਰੈਕਟ ਕਰਨ ਲਈ।

ਗੈਰ-ਓਵਰਲੈਪਿੰਗ ਤੱਤਾਂ (ਵਿਲੱਖਣ ਤੱਤ) ਦੀ ਸੰਖਿਆ (ਕਿਸਮ) ਦੀ ਗਿਣਤੀ ਕਰੋ।

ਸੂਚੀ ਜਾਂ ਟੂਪਲ ਵਿੱਚ ਕਿੰਨੇ ਗੈਰ-ਓਵਰਲੈਪਿੰਗ ਤੱਤ (ਵਿਲੱਖਣ ਤੱਤ) ਹਨ (ਕਿੰਨੀਆਂ ਕਿਸਮਾਂ ਹਨ) ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ, ਉੱਪਰ ਦੱਸੇ ਅਨੁਸਾਰ ਕਾਊਂਟਰ ਜਾਂ ਸੈੱਟ() ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਕਾਊਂਟਰ ਆਬਜੈਕਟ ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਅਸਲ ਸੂਚੀ ਵਿੱਚ ਗੈਰ-ਓਵਰਲੈਪਿੰਗ ਤੱਤਾਂ ਦੀ ਸੰਖਿਆ ਦੇ ਬਰਾਬਰ ਹੈ, ਜੋ len() ਨਾਲ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)

print(len(c))
# 3

ਤੁਸੀਂ ਸੈੱਟ (), ਸੈੱਟ ਕਿਸਮ ਸੈੱਟ ਲਈ ਕੰਸਟਰਕਟਰ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ, ਜੋ ਕਿ ਸੌਖਾ ਹੈ ਜੇਕਰ ਤੁਹਾਨੂੰ ਕਾਊਂਟਰ ਆਬਜੈਕਟ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।

ਸੈੱਟ ਕਿਸਮ ਇੱਕ ਡਾਟਾ ਕਿਸਮ ਹੈ ਜਿਸ ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਤੱਤ ਨਹੀਂ ਹੁੰਦੇ ਹਨ। ਸੈੱਟ() ਨੂੰ ਸੂਚੀ ਪਾਸ ਕਰਨ ਨਾਲ ਡੁਪਲੀਕੇਟ ਮੁੱਲਾਂ ਨੂੰ ਅਣਡਿੱਠ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਐਲੀਮੈਂਟਸ ਦੇ ਤੌਰ ‘ਤੇ ਸਿਰਫ਼ ਵਿਲੱਖਣ ਮੁੱਲਾਂ ਦੇ ਨਾਲ ਸੈੱਟ ਦੀ ਕਿਸਮ ਦੀ ਵਸਤੂ ਵਾਪਸ ਮਿਲਦੀ ਹੈ। ਇਸ ਕਿਸਮ ਦੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ len() ਦੁਆਰਾ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

print(set(l))
# {'a', 'c', 'b'}

print(len(set(l)))
# 3

ਸ਼ਰਤ ਨੂੰ ਸੰਤੁਸ਼ਟ ਕਰਨ ਵਾਲੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਗਿਣੋ।

ਕਿਸੇ ਸੂਚੀ ਜਾਂ ਟੂਪਲ ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਜੋ ਇੱਕ ਖਾਸ ਸਥਿਤੀ ਨੂੰ ਪੂਰਾ ਕਰਦੇ ਹਨ, ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਜਾਂ ਜਨਰੇਟਰ ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਇੱਕ ਉਦਾਹਰਨ ਦੇ ਤੌਰ ‘ਤੇ, ਸੰਖਿਆਵਾਂ ਦੀ ਹੇਠਾਂ ਦਿੱਤੀ ਸੂਚੀ ਲਈ ਨਕਾਰਾਤਮਕ ਮੁੱਲਾਂ ਵਾਲੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਗਿਣੋ

l = list(range(-5, 6))
print(l)
# [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]

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

print([i < 0 for i in l])
# [True, True, True, True, True, False, False, False, False, False, False]

print(sum([i < 0 for i in l]))
# 5

ਜੇਕਰ ਅਸੀਂ ਲਿਸਟ ਕੰਪਰੀਹੈਂਸ਼ਨ ਨੋਟੇਸ਼ਨ ਵਿੱਚ [] ਨੂੰ () ਨਾਲ ਬਦਲਦੇ ਹਾਂ, ਤਾਂ ਸਾਨੂੰ ਇੱਕ ਜਨਰੇਟਰ ਸਮੀਕਰਨ ਮਿਲਦਾ ਹੈ। ਸੂਚੀ ਸਮਝ ਸੰਕਲਪ ਸੰਸਾਧਿਤ ਸਾਰੇ ਤੱਤਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਤਿਆਰ ਕਰਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਜਨਰੇਟਰ ਸਮੀਕਰਨ ਤੱਤਾਂ ਨੂੰ ਕ੍ਰਮਵਾਰ ਪ੍ਰਕਿਰਿਆ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਲਈ ਇਹ ਵਧੇਰੇ ਮੈਮੋਰੀ ਕੁਸ਼ਲ ਹੈ।

ਜਦੋਂ ਜਨਰੇਟਰ ਸਮੀਕਰਨ ਹੀ ਇੱਕ ਆਰਗੂਮੈਂਟ ਹੈ, () ਨੂੰ ਛੱਡਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਇਸਲਈ ਇਸਨੂੰ ਬਾਅਦ ਵਾਲੇ ਕੇਸ ਵਿੱਚ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ।

print(sum((i < 0 for i in l)))
# 5

print(sum(i < 0 for i in l))
# 5

ਜੇ ਤੁਸੀਂ ਗਲਤ ਮੁੱਲਾਂ ਦੀ ਗਿਣਤੀ (ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਜੋ ਸ਼ਰਤ ਨੂੰ ਪੂਰਾ ਨਹੀਂ ਕਰਦੇ) ਦੀ ਗਿਣਤੀ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਨਾ ਵਰਤੋ। ਨੋਟ ਕਰੋ ਕਿ > ਨਾ ਨਾਲੋਂ ਉੱਚੀ ਤਰਜੀਹ ਹੈ (ਇਸਦੀ ਪਹਿਲਾਂ ਗਣਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ), ਇਸਲਈ ਹੇਠਾਂ ਦਿੱਤੀ ਉਦਾਹਰਨ ਵਿੱਚ (i < 0) ਵਿੱਚ ਬਰੈਕਟ () ਜ਼ਰੂਰੀ ਨਹੀਂ ਹਨ।

print([not (i < 0) for i in l])
# [False, False, False, False, False, True, True, True, True, True, True]

print(sum(not (i < 0) for i in l))
# 6

ਬੇਸ਼ੱਕ, ਹਾਲਾਤ ਆਪਣੇ ਆਪ ਨੂੰ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ.

print(sum(i >= 0 for i in l))
# 6

ਕੁਝ ਹੋਰ ਉਦਾਹਰਣਾਂ ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਗਈਆਂ ਹਨ।

ਸੰਖਿਆਵਾਂ ਦੀ ਸੂਚੀ ਲਈ ਅਜੀਬ ਤੱਤਾਂ ਦੀ ਸੰਖਿਆ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਉਦਾਹਰਨ।

print([i % 2 == 1 for i in l])
# [True, False, True, False, True, False, True, False, True, False, True]

print(sum(i % 2 == 1 for i in l))
# 6

ਸਤਰ ਦੀ ਸੂਚੀ ਲਈ ਇੱਕ ਸ਼ਰਤ ਦੀ ਉਦਾਹਰਨ।

l = ['apple', 'orange', 'banana']

print([s.endswith('e') for s in l])
# [True, True, False]

print(sum(s.endswith('e') for s in l))
# 2

ਕਾਊਂਟਰ ਦੀ ਵਰਤੋਂ ਘਟਨਾਵਾਂ ਦੀ ਗਿਣਤੀ ਦੇ ਆਧਾਰ ‘ਤੇ ਗਿਣਤੀ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਆਈਟਮਾਂ () (ਤੱਤ, ਘਟਨਾਵਾਂ ਦੀ ਸੰਖਿਆ) ਦਾ ਇੱਕ ਟੁਪਲ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਅਤੇ ਘਟਨਾਵਾਂ ਦੀ ਸੰਖਿਆ ਸਥਿਤੀ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ।

ਹੇਠਾਂ ਦੋ ਜਾਂ ਦੋ ਤੋਂ ਵੱਧ ਘਟਨਾਵਾਂ ਵਾਲੇ ਤੱਤਾਂ ਨੂੰ ਕੱਢਣ ਅਤੇ ਘਟਨਾਵਾਂ ਦੀ ਕੁੱਲ ਗਿਣਤੀ ਦੀ ਗਿਣਤੀ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਹੈ। ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਕੁੱਲ ਛੇ ਲਈ ਚਾਰ a’s ਅਤੇ ਦੋ c’s ਹਨ।

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)

print(c.items())
# dict_items([('a', 4), ('b', 1), ('c', 2)])

print([i for i in l if c[i] >= 2])
# ['a', 'a', 'a', 'a', 'c', 'c']

print([i[1] for i in c.items() if i[1] >= 2])
# [4, 2]

print(sum(i[1] for i in c.items() if i[1] >= 2))
# 6

ਹੇਠਾਂ ਦੋ ਜਾਂ ਦੋ ਤੋਂ ਵੱਧ ਘਟਨਾਵਾਂ ਵਾਲੇ ਤੱਤਾਂ ਦੀਆਂ ਕਿਸਮਾਂ ਨੂੰ ਐਕਸਟਰੈਕਟ ਕਰਨ ਅਤੇ ਘਟਨਾਵਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਗਿਣਤੀ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਹੈ। ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਦੋ ਕਿਸਮਾਂ ਹਨ, a ਅਤੇ c.

print([i[0] for i in c.items() if i[1] >= 2])
# ['a', 'c']

print([i[1] >= 2 for i in c.items()])
# [True, False, True]

print(sum(i[1] >= 2 for i in c.items()))
# 2

ਇੱਕ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਕਿਸੇ ਸ਼ਬਦ ਦੀਆਂ ਘਟਨਾਵਾਂ ਦੀ ਗਿਣਤੀ ਗਿਣਦਾ ਹੈ।

ਇੱਕ ਠੋਸ ਉਦਾਹਰਨ ਦੇ ਤੌਰ ‘ਤੇ, ਆਉ ਇੱਕ ਸਤਰ ਵਿੱਚ ਇੱਕ ਸ਼ਬਦ ਦੀਆਂ ਘਟਨਾਵਾਂ ਦੀ ਗਿਣਤੀ ਗਿਣੀਏ।

ਪਹਿਲਾਂ, ਰੀਪਲੇਸ() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬੇਲੋੜੇ ਕਾਮੇ ਅਤੇ ਪੀਰੀਅਡਸ ਨੂੰ ਖਾਲੀ ਸਤਰ ਨਾਲ ਬਦਲੋ, ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਨੂੰ ਮਿਟਾਓ। ਫਿਰ, ਸਪੇਸ ਦੁਆਰਾ ਵੱਖ ਕੀਤੀ ਸੂਚੀ ਬਣਾਉਣ ਲਈ split() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।

s = 'government of the people, by the people, for the people.'

s_remove = s.replace(',', '').replace('.', '')

print(s_remove)
# government of the people by the people for the people

word_list = s_remove.split()

print(word_list)
# ['government', 'of', 'the', 'people', 'by', 'the', 'people', 'for', 'the', 'people']

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

print(word_list.count('people'))
# 3

print(len(set(word_list)))
# 6

c = collections.Counter(word_list)

print(c)
# Counter({'the': 3, 'people': 3, 'government': 1, 'of': 1, 'by': 1, 'for': 1})

print(c.most_common()[0][0])
# the

ਉਪਰੋਕਤ ਇੱਕ ਬਹੁਤ ਹੀ ਸਧਾਰਨ ਪ੍ਰਕਿਰਿਆ ਹੈ, ਇਸ ਲਈ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਕੁਦਰਤੀ ਭਾਸ਼ਾ ਪ੍ਰਕਿਰਿਆ ਲਈ NLTK ਵਰਗੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਬਿਹਤਰ ਹੈ।

• Natural Language Toolkit — NLTK 3.6.5 documentation

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

ਇੱਕ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਇੱਕ ਅੱਖਰ ਦੀਆਂ ਘਟਨਾਵਾਂ ਦੀ ਗਿਣਤੀ ਗਿਣੋ।

ਕਿਉਂਕਿ ਸਤਰ ਵੀ ਇੱਕ ਕ੍ਰਮ ਕਿਸਮ ਹਨ, ਉਹਨਾਂ ਨੂੰ count() ਵਿਧੀ ਨਾਲ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜਾਂ ਸੰਗ੍ਰਹਿ ਦੇ ਨਿਰਮਾਤਾ ਨੂੰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਪਾਸ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। Counter().

s = 'supercalifragilisticexpialidocious'

print(s.count('p'))
# 2

c = collections.Counter(s)

print(c)
# Counter({'i': 7, 's': 3, 'c': 3, 'a': 3, 'l': 3, 'u': 2, 'p': 2, 'e': 2, 'r': 2, 'o': 2, 'f': 1, 'g': 1, 't': 1, 'x': 1, 'd': 1})

ਚੋਟੀ ਦੇ 5 ਸਭ ਤੋਂ ਵੱਧ ਅਕਸਰ ਆਉਣ ਵਾਲੇ ਅੱਖਰਾਂ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਉਦਾਹਰਨ।

print(c.most_common(5))
# [('i', 7), ('s', 3), ('c', 3), ('a', 3), ('l', 3)]

values, counts = zip(*c.most_common(5))

print(values)
# ('i', 's', 'c', 'a', 'l')