ಪ್ರಾಜೆಕ್ಟ್ 4: ಪದ ಎಣಿಕೆ ಸಾಧನ (Word Counter)

ಈ ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿ, ನಾವು ಒಂದು ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬರೆಯುತ್ತೇವೆ. ಅದು ಒಂದು ಟೆಕ್ಸ್ಟ್ ಫೈಲ್ ಅನ್ನು ಓದುತ್ತದೆ ಮತ್ತು ಆ ಫೈಲ್‌ನಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ಪದವು ಎಷ್ಟು ಬಾರಿ ಬಂದಿದೆ ಎಂಬುದನ್ನು ಎಣಿಕೆ ಮಾಡುತ್ತದೆ. ಇದು ಟೆಕ್ಸ್ಟ್ ಅನಾಲಿಸಿಸ್‌ನಲ್ಲಿ ಒಂದು ಸಾಮಾನ್ಯ ಮತ್ತು ಮೂಲಭೂತ ಹಂತವಾಗಿದೆ.

ಕಲಿಕೆಯ ಪರಿಕಲ್ಪನೆಗಳು

ಫೈಲ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್ (with open(...))
ಸ್ಟ್ರಿಂಗ್ ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್ (lower(), split(), strip())
ಡಿಕ್ಷನರಿಗಳು (ಪದಗಳನ್ನು ಮತ್ತು ಅವುಗಳ ಎಣಿಕೆಯನ್ನು ಸಂಗ್ರಹಿಸಲು)
for ಲೂಪ್‌ಗಳು (ಫೈಲ್‌ನ ಸಾಲುಗಳು ಮತ್ತು ಪದಗಳ ಮೇಲೆ ಇಟರೇಟ್ ಮಾಡಲು)
ಡಿಕ್ಷನರಿಯ get() ಮೆಥಡ್ ಬಳಕೆ.

ಕೋಡ್

ಮೊದಲು, sample.txt ಎಂಬ ಒಂದು ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ ಮತ್ತು ಅದರಲ್ಲಿ ಕೆಲವು ವಾಕ್ಯಗಳನ್ನು ಹಾಕಿ.

sample.txt:

Hello world.
This is a sample file for our word counter project.
Hello again, world!

word_counter.py:

import string


def count_words(filename):
    """ಒಂದು ಫೈಲ್‌ನಲ್ಲಿರುವ ಪದಗಳನ್ನು ಎಣಿಕೆ ಮಾಡುತ್ತದೆ."""

    word_counts = {}  # ಪದಗಳ ಎಣಿಕೆಯನ್ನು ಸಂಗ್ರಹಿಸಲು ಖಾಲಿ ಡಿಕ್ಷನರಿ

    try:
        with open(filename, 'r', encoding='utf-8') as file:
            for line in file:
                # 1. ಲೈನ್ ಅನ್ನು ಲೋವರ್‌ಕೇಸ್‌ಗೆ ಪರಿವರ್ತಿಸಿ
                line = line.lower()

                # 2. ವಿರಾಮ ಚಿಹ್ನೆಗಳನ್ನು ತೆಗೆದುಹಾಕಿ
                # str.translate() ಬಳಸಿ ಎಲ್ಲಾ ವಿರಾಮ ಚಿಹ್ನೆಗಳನ್ನು ತೆಗೆದುಹಾಕಬಹುದು
                line = line.translate(str.maketrans('', '', string.punctuation))

                # 3. ಲೈನ್ ಅನ್ನು ಪದಗಳಾಗಿ ವಿಂಗಡಿಸಿ
                words = line.split()

                # 4. ಪ್ರತಿ ಪದದ ಎಣಿಕೆಯನ್ನು ಅಪ್‌ಡೇಟ್ ಮಾಡಿ
                for word in words:
                    # get(word, 0) - ಡಿಕ್ಷನರಿಯಲ್ಲಿ ಪದವಿದ್ದರೆ ಅದರ ಎಣಿಕೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ 0 ನೀಡುತ್ತದೆ.
                    word_counts[word] = word_counts.get(word, 0) + 1

    except FileNotFoundError:
        return f"Error: The file '{filename}' was not found."
    except Exception as e:
        return f"An error occurred: {e}"

    return word_counts


def main():
    """ಮುಖ್ಯ ಫಂಕ್ಷನ್."""
    filename = "sample.txt"
    counts = count_words(filename)

    if isinstance(counts, dict):
        print(f"--- Word Counts in '{filename}' ---")
        # ಡಿಕ್ಷನರಿಯನ್ನು ಎಣಿಕೆಯ ಆಧಾರದ ಮೇಲೆ ಸಾರ್ಟ್ ಮಾಡುವುದು (ಹೆಚ್ಚಿನಿಂದ ಕಡಿಮೆಗೆ)
        sorted_counts = sorted(counts.items(), key=lambda item: item[1], reverse=True)

        for word, count in sorted_counts:
            print(f"'{word}': {count}")
        print("---------------------------------")
    else:
        # ಎರರ್ ಸಂದೇಶವನ್ನು ಪ್ರಿಂಟ್ ಮಾಡುವುದು
        print(counts)


if __name__ == "__main__":
    main()

ವಿವರಣೆ

import string: string.punctuation ಅನ್ನು ಬಳಸಿಕೊಂಡು ಎಲ್ಲಾ ಸಾಮಾನ್ಯ ವಿರಾಮ ಚಿಹ್ನೆಗಳ (., ,, !, ಇತ್ಯಾದಿ) ಲಿಸ್ಟ್ ಅನ್ನು ಪಡೆಯಲು ನಾವು ಈ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಇಂಪೋರ್ಟ್ ಮಾಡಿದ್ದೇವೆ.
word_counts = {}: ಪದಗಳನ್ನು ಕೀ (key) ಗಳಾಗಿಯೂ ಮತ್ತು ಅವುಗಳ ಎಣಿಕೆಯನ್ನು ವ್ಯಾಲ್ಯೂ (value) ಗಳಾಗಿಯೂ ಸಂಗ್ರಹಿಸಲು ನಾವು ಡಿಕ್ಷನರಿಯನ್ನು ಬಳಸುತ್ತೇವೆ.
with open(...): ಫೈಲ್ ಅನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ತೆರೆಯಲು ಮತ್ತು ಕೆಲಸ ಮುಗಿದ ನಂತರ ತಾನಾಗಿಯೇ ಮುಚ್ಚಲು with ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಅನ್ನು ಬಳಸಿದ್ದೇವೆ. encoding='utf-8' ವಿವಿಧ ಭಾಷೆಗಳ ಅಕ್ಷರಗಳನ್ನು ಸರಿಯಾಗಿ ಓದಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ಟೆಕ್ಸ್ಟ್ ಪ್ರೊಸೆಸಿಂಗ್:
- line.lower(): ಹೋಲಿಕೆಗಳನ್ನು ಸುಲಭಗೊಳಿಸಲು (ಉದಾ: 'Hello' ಮತ್ತು 'hello' ಒಂದೇ ಎಂದು ಪರಿಗಣಿಸಲು) ಎಲ್ಲಾ ಅಕ್ಷರಗಳನ್ನು ಲೋವರ್‌ಕೇಸ್‌ಗೆ ಪರಿವರ್ತಿಸುತ್ತೇವೆ.
- line.translate(...): ಪದಗಳನ್ನು ಸರಿಯಾಗಿ ಎಣಿಸಲು, ವಾಕ್ಯಗಳಿಂದ ವಿರಾಮ ಚಿಹ್ನೆಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತೇವೆ.
- line.split(): ಪ್ರೊಸೆಸ್ ಮಾಡಿದ ಲೈನ್ ಅನ್ನು ಸ್ಪೇಸ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ಪದಗಳ ಲಿಸ್ಟ್ ಆಗಿ ವಿಂಗಡಿಸುತ್ತೇವೆ.
ಎಣಿಕೆ ಲಾಜಿಕ್:
- word_counts.get(word, 0): ಇದು ಡಿಕ್ಷನರಿಯ ಒಂದು ಉಪಯುಕ್ತ ಮೆಥಡ್. word ಎಂಬ ಕೀ ಡಿಕ್ಷನರಿಯಲ್ಲಿದ್ದರೆ, ಅದು ಅದರ ವ್ಯಾಲ್ಯೂವನ್ನು (ಪ್ರಸ್ತುತ ಎಣಿಕೆ) ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಒಂದು ವೇಳೆ ಕೀ ಇಲ್ಲದಿದ್ದರೆ, ಅದು ನಾವು ನೀಡಿದ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವಾದ 0 ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
- ... + 1: ಪ್ರತಿ ಬಾರಿ ಒಂದು ಪದ ಸಿಕ್ಕಾಗ, ಅದರ ಎಣಿಕೆಯನ್ನು ಒಂದರಿಂದ ಹೆಚ್ಚಿಸುತ್ತೇವೆ.
sorted() ಫಂಕ್ಷನ್: main ಫಂಕ್ಷನ್‌ನಲ್ಲಿ, ನಾವು ಫಲಿತಾಂಶವನ್ನು ಪ್ರದರ್ಶಿಸುವ ಮೊದಲು, ಪದಗಳನ್ನು ಅವುಗಳ ಎಣಿಕೆಯ ಆಧಾರದ ಮೇಲೆ ಇಳಿಕೆ ಕ್ರಮದಲ್ಲಿ (ಹೆಚ್ಚು ಬಾರಿ ಬಂದ ಪದ ಮೊದಲು) ಸಾರ್ಟ್ ಮಾಡುತ್ತೇವೆ. lambda ಫಂಕ್ಷನ್ ಅನ್ನು key ಆಗಿ ಬಳಸಿ ಇದನ್ನು ಸಾಧಿಸಲಾಗಿದೆ.