पायथन प्रोग्राम: दिए गए स्ट्रिंग में शब्द गिनें

स्ट्रिंग में शब्दों की संख्या गिनने के कई तरीके हैं। सरल दृष्टिकोण व्हाइटस्पेस सेपरेटर का उपयोग करता है।

विधि 1: फोर लूप (मूल)

def count_words_for(text):
    total = 1  # कम से कम एक शब्द (यदि खाली नहीं)
    for i in range(len(text)):
        if text[i] in (' ', '\n', '\t'):
            total += 1
    return total

# टेस्ट
test_string = "Python is a high level language. Python is interpreted language. Python is general-purpose programming language"
print(f"शब्द संख्या: {count_words_for(test_string)}")  # 16

आउटपुट

शब्द संख्या: 16

विधि 2: व्हाइल लूप

def count_words_while(text):
    total = 1
    i = 0
    while i < len(text):
        if text[i] in (' ', '\n', '\t'):
            total += 1
        i += 1
    return total

विधि 3: फंक्शन में लपेटें

def count_words(text):
    if not text:
        return 0
    word_count = 1
    for char in text:
        if char in (' ', '\n', '\t'):
            word_count += 1
    return word_count

विधि 4: बिल्ट-इन split() (अनुशंसित)

def count_words_split(text):
    """split() मल्टीपल व्हाइटस्पेस को हैंडल करता है"""
    return len(text.split())

# टेस्ट
text = "Python   is\tawesome\nlanguage"
print(f"split(): {count_words_split(text)}")  # 4

# तुलना
print(f"मैनुअल: {count_words(text)}")  # 6 (गलत - मल्टीपल स्पेस गिनता है)

आउटपुट

split(): 4
मैनुअल: 6

महत्वपूर्ण: मैनुअल लूप मल्टीपल कंसिक्यूटिव व्हाइटस्पेस को अलग-अलग गिनता है, जबकि split() उन्हें एक सेपरेटर मानता है। split() सही परिणाम देता है।

विधि 5: रेगुलर एक्सप्रेशन (जटिल मामलों के लिए)

import re

def count_words_regex(text):
    """शब्द सीमाओं का उपयोग करके गिनें"""
    words = re.findall(r'\b\w+\b', text)
    return len(words)

# टेस्ट
text = "Hello, world! It's a beautiful day."
print(f"Regex: {count_words_regex(text)}")  # 7
print(f"Split: {len(text.split())}")        # 7

विधि 6: विशिष्ट शब्द की घटनाएं गिनें

def count_specific_word(text, target_word):
    """केस-इनसेंसिटिव विशिष्ट शब्द गिनती"""
    words = text.lower().split()
    target = target_word.lower()
    return words.count(target)

text = "Python is great. python is easy. PYTHON is powerful."
print(f"'python' आता है: {count_specific_word(text, 'python')} बार")  # 3

एडवांस्ड: शब्द आवृत्ति विश्लेषण

from collections import Counter
import re

def word_frequency(text):
    """शब्द आवृत्ति काउंट (विराम चिह्न हटाकर)"""
    words = re.findall(r'\b\w+\b', text.lower())
    return Counter(words)

text = "Python is great. Python is easy. Python is powerful!"
freq = word_frequency(text)
print("शब्द आवृत्ति:")
for word, count in freq.most_common():
    print(f"  {word}: {count}")

# आउटपुट:
# python: 3
# is: 3
# great: 1
# easy: 1
# powerful: 1

यूनिकोड/हिंदी टेक्स्ट के लिए

def count_words_unicode(text):
    """यूनिकोड व्हाइटस्पेस और शब्द सीमाओं के लिए"""
    import regex  # pip install regex (बेहतर यूनिकोड सपोर्ट)
    words = regex.findall(r'\p{L}+', text)
    return len(words)

hindi_text = "पायथन एक प्रोग्रामिंग भाषा है। पायथन सीखना आसान है।"
# regex मॉड्यूल के साथ बेहतर काम करता है
print(f"हिंदी शब्द: {len(hindi_text.split())}")  # बेसिक split() भी काम करता है

सारांश: कौन सी विधि चुनें?

किनारे के मामले

# खाली स्ट्रिंग
print(len("".split()))           # 0
print(len("   ".split()))        # 0

# केवल व्हाइटस्पेस
print(len("\n\t ".split()))      # 0

# सिंगल शब्द
print(len("Hello".split()))      # 1

# विराम चिह्न
print(len("Hello,world".split())) # 1 (split स्पेस पर विभाजित करता है)
print(len(re.findall(r'\b\w+\b', "Hello,world"))) # 2