Python में Modulo ऑपरेटर: प्रमुख अवधारणाओं की समझ

Python में modulo ऑपरेटर (%) एक बुनियादी अंकगणितीय ऑपरेटर है, जिसका उपयोग भाग देने पर बचने वाले शेषफल (remainder) को ज्ञात करने के लिए किया जाता है। अवधारणा सरल है, लेकिन यह कई प्रोग्रामिंग अनुप्रयोगों में महत्वपूर्ण भूमिका निभाता है। किसी संख्या के सम या विषम होने की जाँच करने से लेकर अनुक्रमों में चक्रण (cycling), और लीप वर्ष निर्धारित करने तक—modulo ऑपरेटर में महारत Python में आपकी समस्या-समाधान क्षमता को बढ़ा सकती है।

Modulo ऑपरेटर को समझना आवश्यक है क्योंकि यह अक्सर इन स्थितियों में आता है:

• सम और विषम संख्याओं की पहचान
• तत्वों के माध्यम से चक्रीय रूप से लूप करना
• मॉड्यूलर अंकगणित में गणनाएँ लागू करना
• तिथि गणनाएँ, क्रिप्टोग्राफी, और गेमिंग लॉजिक जैसी वास्तविक-जीवन उपयोगिताएँ

इस ब्लॉग में, मैं Python में modulo ऑपरेटर का उपयोग करने पर एक व्यापक मार्गदर्शिका दूँगा—जिसमें वाक्यविन्यास (syntax), विभिन्न संख्या प्रकारों के साथ इसका व्यवहार, उपयोग के मामले, और व्यावहारिक उदाहरण शामिल हैं। यदि आप Python में नए हैं, तो हमारा Introduction to Python कोर्स अवश्य देखें। 

Python में Modulo ऑपरेटर क्या है?

Modulo ऑपरेटर (%) दो संख्याओं के बीच भाग देने पर शेषफल (remainder) निकालता है। यदि दो संख्याएँ a (dividend) और b (divisor) दी गई हों, तो modulo ऑपरेशन वह शेषफल लौटाता है जब a को b से भाग दिया जाता है।

गणितीय पृष्ठभूमि

Modulo की जड़ें मॉड्यूलर अंकगणित में हैं—पूर्णांकों के लिए ऐसा तंत्र जिसमें संख्याएँ किसी निश्चित मान (modulus) तक पहुँचने के बाद "लपेट" जाती हैं। इसका व्यापक उपयोग क्रिप्टोग्राफी, हैशिंग, और चक्रीय गणनाओं में होता है।

12-घंटे की घड़ी की कल्पना करें: 12 के बाद, 13 पर जाने के बजाय हम फिर 1 पर लौट आते हैं। यह मूलतः 12 के modulus के साथ मॉड्यूलर अंकगणित है:

• 13 % 12 = 1, यानी 13 बजे 12-घंटे के प्रारूप में 1 बजे के बराबर है।

Python Modulo वाक्यविन्यास और बुनियादी उपयोग

Python में modulo ऑपरेटर का वाक्यविन्यास सीधा-सादा है:

remainder = dividend % divisorसंचालित द्वारा

कुछ बुनियादी उदाहरण देखते हैं:

# Basic modulo operations
print(7 % 3)     
print(15 % 4)   
print(20 % 5)  संचालित द्वारा

1 
3 
0 संचालित द्वारा

जब हम 7 को 3 से भाग देते हैं, तो 2 भागफल और 1 शेषफल मिलता है। Modulo ऑपरेटर वही शेषफल देता है। इसी तरह, 15 को 4 से भाग देने पर 3 भागफल और 3 शेषफल मिलता है, और 20 को 5 से भाग देने पर ठीक 4 मिलता है, जिसमें कोई शेषफल नहीं रहता।

पूर्णांकों (Integers) के साथ काम

अब जबकि हम modulo ऑपरेटर की मूल बातें समझ चुके हैं, देखते हैं कि यह पूर्णांकों के साथ कैसा व्यवहार करता है।

धनात्मक पूर्णांकों के साथ modulo

धनात्मक पूर्णांकों के साथ काम करना modulo ऑपरेटर का सबसे सरल उपयोग है:

# Examples with positive integers
print(10 % 3)      
print(25 % 7)     
print(100 % 10)  संचालित द्वारा

1 
4 
0 संचालित द्वारा

इन उदाहरणों में, हम यह देखकर परिणाम निकाल सकते हैं कि भाजक (divisor) भाज्य (dividend) में कितनी बार जाता है और उसके बाद क्या बचता है:

• 10 ÷ 3 = 3 शेष 1, इसलिए 10 % 3 = 1
• 25 ÷ 7 = 3 शेष 4, इसलिए 25 % 7 = 4
• 100 ÷ 10 = 10 शेष 0, इसलिए 100 % 10 = 0

ऋणात्मक पूर्णांकों के साथ modulo

ऋणात्मक संख्याओं के साथ काम करते समय modulo ऑपरेटर का व्यवहार अधिक रोचक हो जाता है। Python एक विशिष्ट नियम का पालन करता है: a % b का परिणाम हमेशा b (भाजक) के समान चिन्ह (sign) का होता है।

# Examples with negative integers
print(-10 % 3)    
print(10 % -3)    
print(-10 % -3) संचालित द्वारा

2 
-2 
-1 संचालित द्वारा

ये परिणाम शुरुआत में विरोधाभासी लग सकते हैं, पर वे एक सुसंगत नियम का पालन करते हैं:

1. -10 % 3 के लिए: -1 मिलने की अपेक्षा हो सकती है (यदि आप -10 ÷ 3 = -3 शेष -1 सोच रहे हों), लेकिन Python 2 लौटाता है। ऐसा इसलिए क्योंकि Python 0 और 3 (exclusive) के बीच ऐसी मान ढूँढता है जिसे 3 के किसी गुणज में जोड़ने पर -10 मिले। उत्तर 2 है, क्योंकि -12 + 2 = -10।
2. 10 % -3 के लिए: परिणाम भाजक (-3) के समान चिन्ह का होता है, इसलिए हमें -2 मिलता है। क्योंकि 10 = (-3) × (-4) + (-2)।
3. -10 % -3 के लिए: परिणाम -1 है, क्योंकि -10 = (-3) × 3 + (-1)।

Modulo ऑपरेशनों में ऋणात्मक संख्याओं के साथ Python का यह व्यवहार समझना चक्रीय गणनाओं में महत्वपूर्ण है, जैसे:

• हैशिंग फ़ंक्शनों का कार्यान्वयन
• घड़ी संबंधी गणित (clock arithmetic) से जुड़े प्रश्न हल करना
• सूचियों में ऋणात्मक इंडेक्सिंग लॉजिक संभालना

फ़्लोटिंग-पॉइंट संख्याओं के साथ Modulo

Python का modulo ऑपरेटर केवल पूर्णांकों तक सीमित नहीं है; यह फ़्लोटिंग-पॉइंट संख्याओं के साथ भी काम करता है:

# Modulo with floating-point numbers
print(7.5 % 2)     
print(9.7 % 4.2)  
print(5.0 % 0.2)  संचालित द्वारा

1.5
1.299999999999999
0.19999999999999973संचालित द्वारा

फ़्लोटिंग-पॉइंट संख्याओं में भी वही सिद्धांत लागू होता है: भाग देने के बाद शेषफल लौटाया जाता है। हालाँकि, कंप्यूटर में फ़्लोटिंग-पॉइंट संख्याओं के संग्रह (IEEE 754 फॉर्मेट) के कारण छोटे-छोटे राउंडिंग त्रुटियाँ हो सकती हैं।

उदाहरण के लिए, 1.3 की जगह Python 1.299999999999999 लौटाता है, और 0.2 की जगह 0.19999999999999973। ये सूक्ष्म अशुद्धियाँ फ़्लोटिंग-पॉइंट अंकगणित में सामान्य हैं और सटीक गणनाएँ करते समय ध्यान में रखनी चाहिए।

Python math मॉड्यूल से math.fmod() फ़ंक्शन भी उपलब्ध कराता है, जो फ़्लोटिंग-पॉइंट modulo ऑपरेशनों के लिए विकल्प है और कुछ किनारी (edge) स्थितियों को अलग ढंग से संभाल सकता है:

import math

print(math.fmod(7.5, 2))    
print(math.fmod(-7.5, 2))  

# Compare with Python's modulo operator 
print(-7.5 % 2) संचालित द्वारा

1.5
-1.5
0.5संचालित द्वारा

% और math.fmod() के बीच मुख्य अंतर ऋणात्मक संख्याओं के साथ उनके व्यवहार में है। जहाँ % यह सुनिश्चित करता है कि परिणाम का चिन्ह भाजक के समान हो और मान [0, divisor) के दायरे में हो, वहीं math.fmod() परिणाम का चिन्ह भाज्य (dividend) के समान रखता है। जब शेषफल का चिन्ह महत्वपूर्ण हो, तो यह भेद मायने रखता है।

तो आपको % और math.fmod() में से किसका उपयोग कब करना चाहिए?

• जब आपको सुसंगत साइन व्यवहार चाहिए (जैसे किसी रेंज में चक्रण), तब % का उपयोग करें।
• जब भाज्य का चिन्ह संरक्षित रखना आवश्यक हो—जैसे भौतिकी सिमुलेशन्स या गणितीय फ़ंक्शनों में—तब math.fmod() का उपयोग करें।

Python Modulo में ऋणात्मक संख्याओं का प्रबंधन

जैसा कि हमने पहले के उदाहरणों में देखा, ऋणात्मक संख्याओं के साथ Python के modulo ऑपरेटर का कार्यान्वयन प्रारंभिक अंतर्ज्ञान से मेल न भी खाए। आइए इस व्यवहार को थोड़ा व्यवस्थित रूप से समझें:

# Understanding the pattern with negative numbers
for i in range(-10, 11):
    result = i % 3
    print(f"{i} % 3 = {result}")संचालित द्वारा

-10 % 3 = 2
-9 % 3 = 0
-8 % 3 = 1
-7 % 3 = 2
-6 % 3 = 0
-5 % 3 = 1
-4 % 3 = 2
-3 % 3 = 0
-2 % 3 = 1
-1 % 3 = 2
0 % 3 = 0
1 % 3 = 1
2 % 3 = 2
3 % 3 = 0
4 % 3 = 1
5 % 3 = 2
6 % 3 = 0
7 % 3 = 1
8 % 3 = 2
9 % 3 = 0
10 % 3 = 1संचालित द्वारा

पैटर्न पर ध्यान दें: परिणाम लगातार 0 → 1 → 2 के क्रम में चक्रित होते रहते हैं, चाहे भाज्य धनात्मक हो या ऋणात्मक। यह सुसंगत व्यवहार modulo ऑपरेटर को चक्रीय गणनाओं में विशेष रूप से उपयोगी बनाता है, जैसे:

• वृत्ताकार ऐरे या बफ़र में इंडेक्स घुमाना
• आवधिक फ़ंक्शनों (जैसे समय-आधारित गणनाएँ) में मान मैप करना

वह गणितीय सूत्र जिसे Python modulo के लिए मानता है, यह है:

Import math 

a % b = a - (b * math.floor(a / b))संचालित द्वारा

यह सुनिश्चित करता है कि जब b धनात्मक हो, तो परिणाम हमेशा 0 और b (exclusive) के बीच रहे, और जब b ऋणात्मक हो, तो परिणाम b और 0 (exclusive) के बीच रहे।

Python के Modulo ऑपरेटर का सार

Python में modulo ऑपरेटर (%) भाग देने के ऑपरेशन का शेषफल निकालता है। यह एक सुसंगत गणितीय सूत्र का पालन करता है:

a % b = a - (b * math.floor(a / b))संचालित द्वारा

Python के Modulo व्यवहार के मुख्य नियम:

1. धनात्मक भाजक (b > 0) के लिए
• परिणाम हमेशा [0, b) की रेंज में रहता है (0 सहित, b को छोड़कर)।
2. ऋणात्मक भाजक (b < 0) के लिए
• परिणाम हमेशा (b, 0] की रेंज में रहता है (b को छोड़कर, 0 सहित)।
• शेषफल का चिन्ह b (भाजक) के समान होता है।
3. पूर्णांक और फ़्लोट दोनों के साथ काम करता है
• फ़्लोटिंग-पॉइंट संख्याओं में % वही सूत्र मानता है, पर फ़्लोटिंग-पॉइंट प्रिसिशन के कारण छोटे राउंडिंग एरर आ सकते हैं।
4. % और math.fmod() में अंतर
• % शेषफल का चिन्ह भाजक के समान रखता है।
• math.fmod(a, b) शेषफल का चिन्ह भाज्य के समान रखता है।

Modulo ऑपरेटर के सामान्य उपयोग

आइए modulo ऑपरेटर के व्यावहारिक अनुप्रयोगों को देखें और कुछ और उदाहरण देखें। 

किसी संख्या का सम या विषम होना जाँचना

Modulo ऑपरेटर का सबसे आम उपयोगों में से एक है यह निर्धारित करना कि कोई संख्या सम है या विषम:

def is_even(number):
    return number % 2 == 0

def is_odd(number):
    return number % 2 != 0

# Testing the functions
numbers = [1, 2, -3, 4, -5, 6, 7]
for num in numbers:
    if is_even(num):
        print(f"{num} is even")
    else:
        print(f"{num} is odd")संचालित द्वारा

1 is odd
2 is even
-3 is odd
4 is even
-5 is odd
6 is even
7 is oddसंचालित द्वारा

यह इसलिए काम करता है क्योंकि सम संख्याएँ 2 से भाग देने पर 0 शेषफल छोड़ती हैं, जबकि विषम संख्याएँ 1 या -1 शेषफल छोड़ती हैं।

अनुक्रम में चक्रण (cycling)

Modulo ऑपरेटर चक्रीय व्यवहार बनाने के लिए उपयुक्त है, जैसे किसी सूची की वस्तुओं के बीच घूमना:

days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]

def get_day(n):
    # Get the day of the week for the nth day, where day 0 is Monday
    return days[n % len(days)]

# Starting from Monday (day 0), what day is it after 10 days?
print(get_day(10))  # Output: "Thursday"

# What day was it 15 days ago from Monday?
print(get_day(-15))  # Output: "Sunday"संचालित द्वारा

Thursday
Sundayसंचालित द्वारा

इस उदाहरण में, चाहे n कितना भी बड़ा या छोटा (ऋणात्मक) हो जाए, फ़ंक्शन हमेशा सप्ताह का मान्य दिन लौटाएगा।

लीप वर्ष की गणना

हालाँकि लीप वर्ष की गणना में कई शर्तें होती हैं, modulo ऑपरेटर इस एल्गोरिथ्म का केंद्रीय हिस्सा है:

लीप वर्ष निम्नलिखित नियमों का पालन करते हैं:

• यदि कोई वर्ष 4 से विभाज्य है, तो वह लीप वर्ष है।
• पर यदि वह 100 से विभाज्य है, तो वह लीप वर्ष नहीं है।
• जब तक कि वह 400 से भी विभाज्य न हो—ऐसी स्थिति में वह लीप वर्ष है।

def is_leap_year(year):

    return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)

# Test the function
years = [1900, 2000, 2004, 2020, 2023, 2024]
for year in years:
    if is_leap_year(year):
        print(f"{year} is a leap year")
    else:
        print(f"{year} is not a leap year")संचालित द्वारा

1900 is not a leap year
2000 is a leap year
2004 is a leap year
2020 is a leap year
2023 is not a leap year
2024 is a leap yearसंचालित द्वारा

यह सुनिश्चित करता है कि ग्रेगोरियन कैलेंडर के लीप वर्ष नियम सही तरीके से लागू हों।

Python Modulo के व्यावहारिक उदाहरण

यहाँ कुछ तरीके हैं जिनसे आप अपने Python प्रोजेक्ट्स में modulo ऑपरेटर का उपयोग कर सकते हैं: 

लूप्स में modulo का उपयोग

Modulo ऑपरेटर का अक्सर लूप्स में उपयोग होता है ताकि नियमित अंतराल पर क्रिया की जा सके:

# Print a message every 5 iterations
for i in range(1, 11):
    print(f"Processing item {i}", end=": ")
    if i % 5 == 0:
        print("Checkpoint reached!")
    else:
        print("Continuing...")संचालित द्वारा

Processing item 1: Continuing...
Processing item 2: Continuing...
Processing item 3: Continuing...
Processing item 4: Continuing...
Processing item 5: Checkpoint reached!
Processing item 6: Continuing...
Processing item 7: Continuing...
Processing item 8: Continuing...
Processing item 9: Continuing...
Processing item 10: Checkpoint reached!संचालित द्वारा

यह पैटर्न बैच प्रोसेसिंग, प्रोग्रेस रिपोर्टिंग, या किसी भी ऐसी कार्यक्षमता के लिए उपयोगी है जिसे आवधिक रूप से होना हो।

वास्तविक-जीवन अनुप्रयोगों में modulo

पासवर्ड हैशिंग

क्रिप्टोग्राफ़िक अनुप्रयोगों में modulo अंकगणित बुनियादी होता है। यहाँ एक साधारण उदाहरण है कि किसी मूलभूत हैशिंग फ़ंक्शन में modulo का उपयोग कैसे हो सकता है:

def simple_hash(text, modulus=1000000007):
    """A very simple hash function using modulo."""
    hash_value = 0
    for char in text:
        # Combine the current hash with the character's Unicode code point
        hash_value = (hash_value * 31 + ord(char)) % modulus
    return hash_value

# Test with some strings
print(simple_hash("hello"))  # Output a number between 0 and 1000000006
print(simple_hash("world"))
print(simple_hash("hello world"))
print(simple_hash("こんにちは"))  संचालित द्वारा

99162322
113318802
204910434
807637228संचालित द्वारा

यह एक बहुत बुनियादी उदाहरण है—वास्तविक क्रिप्टोग्राफिक हैशिंग कहीं अधिक जटिल होती है। Modulo ऑपरेशन यह सुनिश्चित करता है कि हैश मान एक प्रबंधनीय दायरे में रहे, जबकि एक अच्छे हैश फ़ंक्शन के गुण भी बने रहें।

घड़ी समय की गणना

समय गणनाओं को संभालने में modulo उपयोगी होता है, जैसे घंटों की बड़ी संख्या को मानक समय प्रारूप में बदलना।

def convert_to_12_hour_format(hours):
    return hours % 12 or 12  # Ensure 0 maps to 12

# Example
print(convert_to_12_hour_format(13))  # Output: 1
print(convert_to_12_hour_format(24))  # Output: 12
print(convert_to_12_hour_format(36))  # Output: 12संचालित द्वारा

यहाँ, modulo ऑपरेटर 12-घंटे के प्रारूप में घंटों को लपेट देता है।

गेम डेवलपमेंट: मल्टीप्लेयर टर्न सिस्टम लागू करना

मल्टीप्लेयर टर्न-आधारित गेम्स में, हम खिलाड़ियों के बीच चक्रण करने के लिए modulo का उपयोग कर सकते हैं।

players = ["Alice", "Bob", "Charlie"]
turns = 10

for turn in range(turns):
      current_player = players[turn % len(players)]
      print(f"Turn {turn + 1}: {current_player}'s move")संचालित द्वारा

Turn 1: Alice's move
Turn 2: Bob's move
Turn 3: Charlie's move
Turn 4: Alice's move
Turn 5: Bob's move
Turn 6: Charlie's move
Turn 7: Alice's move
Turn 8: Bob's move
Turn 9: Charlie's move
Turn 10: Alice's moveसंचालित द्वारा

बारकोड में अंकों का मान्यकरण

कई बारकोड प्रणालियाँ स्कैन किए गए अंकों में त्रुटियाँ पहचानने के लिए modulo ऑपरेशन का उपयोग करती हैं।

def is_valid_isbn13(isbn):
    digits = [int(d) for d in str(isbn)]
    checksum = sum(d * (1 if i % 2 == 0 else 3) for i, d in enumerate(digits))
    return checksum % 10 == 0

# Example ISBN Checksum validation
print(is_valid_isbn13(9780306406157))  # Output: True
print(is_valid_isbn13(9780306406158))  # Output: Falseसंचालित द्वारा

True
Falseसंचालित द्वारा

निष्कर्ष

Modulo ऑपरेटर Python के टूलकिट में एक बहुमुखी साधन है, जो सरल शेषफल गणनाओं से कहीं आगे जाता है। सम/विषम निर्धारण से लेकर चक्रीय पैटर्न वाले जटिल एल्गोरिद्म तक—modulo विभिन्न प्रोग्रामिंग चुनौतियों के लिए अधिक सुथरे और सुरुचिपूर्ण समाधान सक्षम करता है।

मौलिक कार्यक्षमता के साथ-साथ विभिन्न प्रकार की संख्याओं पर इसके सूक्ष्म व्यवहार को समझकर, आप अधिक कुशल और पठनीय कोड लिखने के लिए modulo ऑपरेटर का लाभ उठा सकते हैं। अगली बार जब आप चक्र, रोटेशन, या आवधिक घटनाओं वाली लॉजिक लागू करें, तो याद रखें कि modulo ऑपरेटर शायद वही समाधान है जिसकी आपको तलाश है।

यदि आप अपने प्रोजेक्ट्स में Python का उपयोग करना और सीखना चाहते हैं, तो हमारा इंटरैक्टिव कोर्स Introduction to Data Science in Python देखें।