Python'dagi modulo operatori (%): misollar bilan to'liq qo'llanma

Ortib qolgan ovqatni nima qilasiz? Isitasizmi? Undan boshqa taom tayyorlaysizmi? Tashlab yuborasizmi? Python'ning modulo operatori yordamida floor division'dan "ortib qolgan" qismni — qoldiqni olasiz. Bu qoldiqlar bilan nima qilish esa o'zingizga bog'liq.

Ushbu maqolada modulo operatori nima ekanini, u nima qilishini va uni butun sonlar hamda float'lar bilan qanday ishlatish mumkinligini ko'rib chiqamiz. Sizga manfiy sonlar bilan bog'liq ba'zi chalkash "tuzoq"larni ko'rsatamiz, shuningdek modulo operatorini math.fmod() va divmod() kabi boshqa Python variantlari bilan taqqoslaymiz. O'rganadigan narsa ko'p, shuning uchun boshlaymiz.

Python'da modulo operatori nima va u qanday ishlaydi?

Python'ning modulo operatori floor division hisobidan keyin qolgan qoldiqni beradi. Modulus deb ham ataladigan bu qoldiq, aslida, boshlang'ich matematika kursida uchratgan qoldig'ingizning o'zginasi. Ammo bugungi kompyuter asrida modulo amali sikllar, qonuniyatlar va cheklovlar bilan bog'liq real hayotiy muammolarni hal qilishda nihoyatda foydali bo'lib chiqadi.

Modulo operatori qanday ishlashini chuqurroq tushunish uchun oddiy soat siferblatini tasavvur qiling. Yarim tundan boshlang: minut mili ham, soat mili ham to'ppa-to'g'ri yuqoriga qaragan. Daqiqalar o'tgan sari minut mili siferblat bo'ylab soat mili yo'nalishida aylanadi, toki oltmish daqiqa o'tguncha. Shunda soat mili birga siljiydi, minut mili esa boshlang'ich, nol daqiqali holatiga qaytadi. So'ng u yana bir soat o'tguncha 0 dan 59 daqiqagacha bo'lgan yo'lida davom etadi.

Bu yerda soat mili o'tgan daqiqalar soni va 60 o'rtasidagi floor division'ni ifodalaydi. Minut mili esa shu bo'lishning modulus'ini, ya'ni qoldig'ini ko'rsatadi. Masalan, 90 daqiqadan keyin vaqt 1:30 bo'ladi — bir soat va qolgan 30 daqiqa.

Python'dagi sintaksis va asosiy foydalanish

Python'da modulus'ni foiz belgisi (%) bilan ifodalanadigan modulo operatori yordamida topishingiz mumkin. Ikki son o'rtasidagi floor division qoldig'ini topish uchun uni shu ikki son orasiga qo'ying. Masalan:

print(7 % 2) # Expected result:
# 1

7 ni 2 ga bo'lsangiz, 3 chiqadi va 1 qoldiq qoladi. Modulo operatori qoldiqni, ya'ni 1 ni qaytaradi.

Python modulo operatori qanday ishlashini ko'rsatadigan yana bir nechta holat:

print(8 % 2) 
print(100 % 3)
print(90 % 60) 

# Expected result:
# 0
# 1
# 30

Modulo integer division va floor division operatori bilan qanday bog'liq?

Avvalroq modulo operatori floor division'ning qoldig'ini berishini aytib o'tgan edik; floor division ba'zan integer division deb ham ataladi. Masalan, 7 va 2 ning floor division natijasi 3; qoldiq esa 1, ya'ni modulus.

Python'da floor division operatori ikkita to'g'ri slash — //, % esa modulo'ni ifodalaydi. Bu ikki operator bir-biri bilan chambarchas bog'liq. Aslida, Python modular arifmetikani kafolatlaydi, ya'ni:

a = b * (a // b) + (a % b)

bu yerda * ko'paytirishni bildiradi, qo'shish uchun esa Python + dan foydalanadi. Keling, bu formulani hozirgina ko'rib chiqqan misolimizda qayta tekshirib ko'raylik. a = 7 va b = 2 deb oling va tenglamaning o'ng tomonini hisoblang:

print(2 * (7 // 2) + (7 % 2)) 

# Expected result:
# 7

Butun sonlar bilan modulo amali

Ko'pincha Python'da modulo operatorini (%) butun sonlar bilan ishlatasiz. Hozirgacha ko'rgan misollaringiz uning ichkarida aynan qanday ishlashini ko'rsatadi: ikki qiymatni bo'ling, shu hisobdan keyin nima qolsa, o'sha qoldiq bo'ladi va uni modulo operatori qaytaradi.

Agar ikkala operand ham butun son bo'lsa, Python'ning modulo amali int qaytaradi. Modulo'ga juda kichik yoki juda katta kattalikdagi butun sonlarni berishingiz mumkin:

print(10000000000000000 % 2)
print(2 % 10000000000000000) 

# Expected result:
# 0
# 2

Modulo yordamida juft yoki toq sonlarni tekshirish

Python'da modulo operatorini turli joylarda uchratasiz, ammo undan foydalanishning eng mashhur usullaridan biri sonning juft yoki toqligini tekshirishdir. Butun sonning 2 bo'yicha modulo'si har doim ikki mumkin bo'lgan natijadan birini beradi: juft sonlar uchun 0 yoki toq sonlar uchun 1.

Bu sizga juft va toq sonlar uchun alohida natija beradigan kod yozishga yordam beradi va kodingiz hatto ekstremal qiymatlarda ham ishlashda davom etadi. Aytaylik, veb-saytingiz uchun satrlari navbatma-navbat bo'yalgan jadval yaratmoqchisiz: juft satrlar och kulrang, toq satrlar oq. Jadval satrlaringiz rangini dasturlash uchun modulo operatoridan foydalanishingiz mumkin:

if row_number % 2 == 0:
    row_color = "light_gray"
else:
    row_color = "white"

Bu yerda sizga faqat bitta modulo hisobi kerak, chunki barcha butun sonlar uchun modulus 0 yoki 1 bo'ladi va bu kod row_number juda katta bo'lib ketsa ham ishlaydi.

Floating-point sonlar bilan modulo va floating-point aniqligi

Kamroq uchrasa-da, modulo operatorini floating-point sonlarga ham qo'llashingiz mumkin. Modulus ta'rifi float'lar uchun ham o'z kuchida qoladi:

a % b = b * (a // b) - a

Masalan:

print(6.5 % 2) 

# Expected result:
# 0.5

2 soni 6.5 ichiga roppa-rosa 3 marta sig'adi va shundan keyin sizda 0.5 qoldiq qoladi.

Floating-point sonni modulo operatorining bitta yoki ikkala operand'i sifatida ishlatishingiz mumkin. Faqat shuni yodda tutingki, modulo operatoriga har safar float kirsa, Python natijasida ham float olasiz. Amalda bu aniq, lekin taxminiy natija olishingizni anglatadi; biroq agar floating-point son modulo operatoringizning bo'luvchisi bo'lsa, alohida e'tibor bering.

0.3 ni 0.1 ga bo'lishni ko'rib chiqing. Floor division natijasi 3, modulus esa 0 bo'lishini kutasiz. Ammo Python'da quyidagicha bo'lishi mumkin:

print(0.3 // 0.1)
print(0.3 % 0.1) 

# Expected result:
# 2.0
# 0.09999999999999998

Floating-point sonlar aniq emas, shuning uchun 0.3 ni 0.1 ga bo'lganingizda Python 2.9999999999999996 ni hosil qiladi — bu son 3 ga yaqin, lekin aynan 3 emas. Floor division bu sonni eng yaqin butun songa qadar pastga yaxlitlashni (2.0) talab qiladi, modulo esa ortib qolgan qismni (0.09999999999999998) so'raydi.

Agar kodingizda floating-point sonlar bo'lishini kutsangiz, unga tekshiruvlar qo'shishingiz kerak bo'ladi. Qiymatlarni eng yaqin butun songa masshtablashingiz (masalan, o'ndan yoki yuzdan birlarda ishlashingiz) yoki modulus'ingizni (aytaylik, x) qat'iy tengliklar (x % 0.1 == 0) o'rniga comparison operator'lar (x % 0.1 < 1e-9 yoki (0.1 - (x % 0.1)) < 1e-9) bilan tekshirishingiz mumkin.

Python va boshqa tillarda manfiy sonlar bilan ishlash

Hozirgacha modulo operatorini musbat sonlar uchun ko'rdingiz, lekin manfiy operand'lar uchun nima bo'ladi? Bu Python boshqa dasturlash tillaridan farq qiladigan jihatlardan biri.

Python modulo operatorida manfiy sonlar bilan ishlashda matematik yondashuvni qo'llaydi. Python'da a % b natijasi har doim bo'luvchi (b) bilan bir xil ishoraga ega bo'ladi. Bu quyidagini anglatadi:

print(-5 % 3)
print(5 % -3) 

# Expected result:
# 1
# -1

Python avval ko'rgan matematik arifmetik hisobingizga amal qiladi:

a % b = a - b * (a // b)

a = -5 va b = 3 ni qo'ysak, -5 // 3 -2 ni beradi, chunki Python har doim manfiy cheksizlik tomon pastga yaxlitlaydi. Ikkinchi hadda manfiylar bir-birini yo'qqa chiqargach, hosil bo'lgan tenglama +1 ga soddalashadi.

C, Java va JavaScript kabi tillarda modulo'ning xatti-harakati boshqacha. U yerda a % b modulus natijasi bo'linuvchi (a) bilan bir xil ishoraga ega bo'ladi. Bu dasturlash tillari integer division'da natijani manfiy cheksizlik tomon emas, nol tomon truncate qiladi. Shuning uchun C, Java va JavaScript'da -5 % 3 bizga -2 ni beradi, chunki -5 ni 3 ga bo'lsak, -1 chiqadi va -2 qoladi.

Python'ning bo'luvchi ishorasiga moslashish xatti-harakati oxir-oqibat sizga tozaroq kod beradi va ko'plab real hayotiy ilovalarda yaxshi ishlaydi. Bo'luvchi b berilgan bo'lsa, Python % natijasi har doim 0 va b orasida yotishini kafolatlaydi. Python bilan siz belgilangan sikl ichida qolasiz va hech qachon bu oraliqdan tashqariga chiqmaysiz.

Agar Python'da siklik masalani yechayotgan bo'lsangiz, sikldagi o'rningizni shunchaki quyidagicha kuzatib borishingiz mumkin:

index = i % n

bu yerda i — hisoblagichingiz, n esa siklingiz o'lchami. Bu yondashuv tabiiy ravishda vaqt bilan bog'liq masalalar kabi siklik masalalarga ham tatbiq etiladi. Boshlang'ich nuqtangiz va offset berilganda daqiqalarni quyidagicha yangilashingiz mumkin: minute = (current_minute + offset) % 60

Bu hisob offset manfiy bo'lsa ham ishlaydi. Python baribir sizga musbat daqiqa qiymatini beradi, chunki natija ishorasi bo'luvchiga — 60 ga mos keladi.

Modulo operatori, divmod() va math.fmod() farqi

Yana ikkita standart Python funksiyasi ham modular arifmetikada yordam berishi mumkin. divmod() funksiyasi bo'linuvchi va bo'luvchini qabul qiladi hamda bo'linma va qoldiqni birgalikda tuple sifatida qaytaradi. divmod()'dan foydalanish uchun hech qanday kutubxonani import qilishingiz shart emas; u Python codebase'idagi built-in funksiya. U quyidagicha ishlaydi:

print(divmod(7, 2))
print(divmod(1, -3)) 

# Expected result:
# (3, 1)
# (0, -1)

Qaytarilgan tuple'ning birinchi qiymati floor division natijasi, ikkinchisi esa modulus'ingiz.

Boshqa funksiya — fmod() math kutubxonasidan keladi, shuning uchun undan foydalanish uchun kodingiz boshiga import math qo'shishingiz kerak. math.fmod()'ga avval bo'linuvchini, keyin bo'luvchini berasiz, ammo natijada faqat float ko'rinishidagi modulus'ni olasiz. Biroq bu funksiya % dan farq qiladi, chunki manfiy sonlarni C, Java va JavaScript kabi qayta ishlaydi. math.fmod() natijasining ishorasi bo'luvchingizga emas, bo'linuvchingizga mos keladi. Masalan:

import math
print(math.fmod(-5, 3)) 

# Expected result:
# -2

Python'da modulus topishning uchala usulining yonma-yon taqqoslanishi:

Amal	Natija	Ta'rif	Qoldiq ishorasi nimaga mos keladi	(-5, 3) uchun misol	Odatiy qo'llanish holati
%	Faqat qoldiq	a - b * (a // b)	Bo'luvchi	1	Sikllar, indexing
divmod()	(Bo'linma, Qoldiq)	(a // b, a % b)	Bo'luvchi	(-2, 1)	Bo'linma + qoldiq natijalari kerak bo'lgan masalalar
math.fmod()	Faqat qoldiq (float)	a - b * math.trunc(a / b)	Bo'linuvchi	-2	Manfiy sonlarni C uslubida qayta ishlash kerak bo'lganda

Arithmetic operator'lar orasidagi precedence

Python kodingizda ko'pincha bir nechta matematik amallarni birlashtirishingiz kerak bo'ladi. Bitta tenglamadagi bir nechta matematik amalni hisoblashda Python PEMDAS'ga (qavslar, darajalar, ko'paytirish va bo'lish, qo'shish va ayirish) amal qiladi. Python'da modulo operatori % ko'paytirish va bo'lish bilan bir xil precedence'ga ega. Darajaga ko'tarish modulo'dan kuchliroq bog'lanadi, shuning uchun ** birinchi hisoblanadi.

Mana bir misol:

print(5 + 4 * 2 % 3 - 1) # Expected result:
# 6

PEMDAS bo'yicha avval 4 ni 2 ga ko'paytiramiz, bu 8 ni beradi. Keyin modulo amalini bajarasiz, chunki u ko'paytirish bilan bir xil precedence'ga ega; 8 ning 3 bo'yicha modulo'si 2 ga teng. Nihoyat, 7 ni olish uchun 5 va 2 ni qo'shing, so'ng natijani — 6 ni olish uchun 1 ni ayiring.

Amaliy misollar va qo'llanish holatlari

Ushbu maqolada Python modulo operatorining bir nechta misolini allaqachon ko'rdingiz, ammo u umuman qanday ishlashini o'rganib olganingizdan keyin modulo amalini ko'plab real dasturlash muammolarini hal qilishda qo'llashga tayyor bo'lasiz. Ilhom uchun bir nechta qo'llanish holatlari.

List'lar bo'ylab aylanish

Elementlardan iborat list'lar Python kodida tez-tez uchraydi va modulo operatori bu list elementlari bo'ylab chegaradan chiqib ketmasdan aylanishning toza usulini taqdim etadi.

Aytaylik, sizda aylana tartibida navbatma-navbat boradigan uchta sevimli qahvaxonangiz bor. Aprelning har bir kunida qaysi qahvaxonaga borishni aniqlash uchun Python va modulo'dan foydalanishingiz mumkin:

coffee_shops = ["Coffee Clubhouse", "Kate's Cafe", "Jammin' Java"]
for i in range(0, 30): 
    print(f"April {i+1}: {coffee_shops[i % len(coffee_shops)]}")

# Expected result:
# April 1: Coffee Clubhouse
# April 2: Kate's Cafe
# April 3: Jammin' Java
# April 4: Coffee Clubhouse
# April 5: Kate's Cafe
# ...
# April 30: Jammin' Java

Round-Robin Scheduling

Round-robin scheduling vazifalarni odamlarga yoki hatto mashinalarga taqsimlash kerak bo'lganda qo'l keladi va list'lar bo'ylab aylanish uchun modulo'dan foydalanishning tabiiy davomi hisoblanadi. Ushbu code snippet ortib boruvchi so'rov ID'lari asosida ishni uchta server o'rtasida qanday taqsimlashni ko'rsatadi:

servers = ["Server1", "Server2", "Server3"]
for request_id in range(10): 
    server = servers[request_id % len(servers)]    
    print(f"Request {request_id} -> {server}")

# Expected result:
# Request 0 -> Server1
# Request 1 -> Server2
# Request 2 -> Server3
# Request 3 -> Server1
# ...
# Request 9 -> Server1

Birliklarni o'girish: soniyalardan soat va daqiqalarga

Soniya, daqiqa va soat kabi siklik birliklarni o'girish ham modular arifmetikani talab qiladi. Soniyalarni soat va daqiqalarga o'girish kabi vazifalar uchun modulo operatoridan yoki sizga bo'linma va qoldiqni birga beradigan divmod() kabi funksiyadan foydalanishingiz mumkin:

total_seconds = 10000
minutes, seconds = divmod(total_seconds, 60)
hours, minutes = divmod(minutes, 60)
print(f"{total_seconds} seconds is {hours} hours {minutes} minutes {seconds} seconds.")

# Expected result:
# 10000 seconds is 2 hours 46 minutes 40 seconds.

Kabisa yilini tekshirish

Hech o'ylab ko'rganmisiz, 1924-yil kabisa yili bo'lganmi? Modulo operatori yordamida buni osongina bilib olishingiz mumkin. Yil 4 ga bo'linishini tekshiradigan kichik funksiya yozing, xolos. Agar bo'linsa, bu kabisa yili (faqat u 100 ga ham bo'linmasligi kerak… 400 ga ham bo'linadigan bo'lsa, bundan mustasno).

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

print(is_leap_year(1924))

# Expected result:
# True

Keng tarqalgan xatolar va ularni qanday tuzatish mumkin

Modulo amali qanchalik foydali bo'lmasin, undan qochish yoki yuzaga kelsa, tuzatish kerak bo'lgan bir nechta muammo bor. Keling, modulo bilan ishlaganda uchratadigan eng keng tarqalgan xatolarni muhokama qilamiz.

ZeroDivisionError

Nolga bo'lish matematikada ham, kompyuter dasturlashda ham qat'iyan man etilganini bilsangiz kerak. Esda tutingki, floor division (//) Python'dagi modulus hisobining bir qismi, shuning uchun modulo'ning bo'luvchi operand'i sifatida ham noldan qochishingiz kerak. Agar tasodifan shunday qilsangiz, quyidagiga o'xshash ZeroDivisionError olasiz:

>>> 4 % 0
Traceback (most recent call last): File "<python-input-1>", line 1, in <module> 4 % 0 ~~^~~
ZeroDivisionError: integer modulo by zero

Bunday xatoga duch kelganingizda modulo operatoringizning bo'luvchisi hech qachon nolga teng bo'lib qolmasligini qayta tekshiring va kerak bo'lsa, tuzating.

Manfiy sonlarda kutilmagan ishora

Python'da modulo operatorining natijasi har doim bo'luvchining ishorasiga mos keladi, ammo manfiy sonlar uchun modulus'ni endigina hisoblay boshlaganingizda natijalar baribir ajablanarli tuyulishi mumkin, ayniqsa siz boshqacha qoidaga amal qiladigan C, Java yoki JavaScript kabi boshqa dasturlash tillaridagi modulo bilan allaqachon tanish bo'lsangiz.

Agar Python'da manfiy operand'lar bilan qoldiqni birinchi marta hisoblayotgan bo'lsangiz, kutilgan va haqiqiy natijalarga alohida e'tibor bering. Python'da modulus har doim 0 va bo'luvchi orasidagi biror joyga tushadi. Agar bo'luvchi musbat bo'lsa, qoldiq ham musbat bo'ladi. Biroq bo'luvchingiz manfiy bo'lsa, manfiy modulus olasiz.

Xulosa

Python'da modulo operatori (%) floor division (//) bajarilgandan keyingi qoldiqni qaytaradi. U juft va toq sonlarni tekshirish, vaqt birliklarini o'girish va vazifalarni round-robin tarzida rejalashtirish kabi turli real hayotiy ilovalar uchun foydali ekanini ko'rasiz. Modulo floating-point sonlar va manfiy qiymatlar uchun ham ishlasa-da, kutilmagan natijalar yoki kod xatolaridan qochish uchun Python ularning har birini qanday qayta ishlashiga diqqat bilan e'tibor berishingiz kerak.

Agar modulo operatori haqida ko'proq bilmoqchi bo'lsangiz, AI Tutor'ni sinab ko'ring. Ushbu prompt sizga boshlab olishga yordam beradi: