Modules
āĻāϤāĻĻিāύে āĻāĻĒāύি āĻāĻĒāύাāϰ āĻĒাāĻāĻĨāύ āĻĒ্āϰোāĻ্āϰাāĻŽিং āĻļেāĻাāϰ āϝাāϤ্āϰাā§ āĻ āύেāĻāĻা āĻāĻিā§ে āĻিā§েāĻেāύ। āĻŦāϞāϤে āĻেāϞে āĻāĻĒāύি āĻĒাāĻāĻĨāύ āĻĒ্āϰোāĻ্āϰাāĻŽিং āĻাāώাāϰ āĻŽৌāϞিāĻ āϏāĻāϞ āĻŦিāώ⧠āĻেāύে āĻিā§েāĻেāύ। āϤāĻŦে āĻāĻāĻা āĻļেāώ āϧাāĻĒ āĻŦাāĻি āϰā§েāĻে, āϏেāĻি āĻšāϞো āĻŽāĻĄিāĻāϞ। āĻŽāĻĄিāĻāϞ āĻŦোāĻাāϰ āĻĒāϰ āĻāĻĒāύি āĻāĻĒāύাāϰ āĻĒ্āϰোāĻ্āϰাāĻŽিং āĻļেāĻাāϰ āϝাāϤ্āϰাā§ āĻĒāϰāĻŦāϰ্āϤী āϧাāĻĒে āϧাāĻĒāĻুāϞোāϤে āϝেāϤে āĻĒাāϰāĻŦেāύ। āϤাāĻšāϞে āĻāϞুāύ āĻļুāϰু āĻāϰা āϝাāĻ।
āĻŽāĻĄিāĻāϞ āĻি ?
āĻāĻŽাāĻĻেāϰ āĻিāϰāύ্āϤāϰ āύিā§āĻŽাāύুāϏাāϰে āĻāĻŦাāϰো āĻāĻāĻি āĻāϞ্āĻĒ āĻĻিā§ে āĻļুāϰু āĻāϰি :
āĻŦিāĻাāϞāĻŦেāϞা āĻŽāύোāϰāĻŽ āĻļুāĻ্āϰ āĻĒāϰিāĻŦেāĻļে āύāĻĻীāϰ āϧāϰে āĻāĻি āĻাāϏেāϰ āĻāĻĒāϰ āĻļুā§ে āύিāĻļ্āĻিāύ্āϤে āĻāĻাāĻļেāϰ āϏাāĻĻা āĻŽেāĻāĻুāϞি āĻাāϏে āϝেāϤে āĻĻেāĻāĻিāϞ āĻāĻŽাāĻĻেāϰ āĻŦাāĻĒ্āĻĒি āĻĻাāĻĻু। āĻāĻĻেāϰ āĻুāĻি āĻĒ্āϰাā§ āĻļেāώেāϰ āĻĻিāĻে, āĻāϞেāĻ āĻোāϞাāϰ āĻĒāϰ, āĻি āĻি āĻāϰāĻŦে ? āϏেāĻ āϏāĻŽāϏ্āϤ āĻŦিāώā§েāϰ āĻāĻāĻা āĻāϏā§া āĻĒ্āϞ্āϝাāύ āĻāϰāĻিāϞ āϏে। āĻšāĻ াā§, āϤাāϰ āĻŽāύে āĻĒā§āϞো āĻুāĻিāϤে āĻĻেāĻā§া āĻšোāĻŽāĻā§াāϰ্āĻ āĻুāϞো āĻুঁā§েāĻ āĻĻেāĻেāύি āϏে। āĻāĻāύ āĻি āĻāϰāĻŦে ? āĻāϤো āĻāĻŽ āϏāĻŽā§ে āĻিāĻাāĻŦে āϏে āĻāĻ āĻŦিāĻļাāϞ āϏāĻŽāϏ্āϝাāϰ āϏāĻŽাāϧাāύ āĻāϰāĻŦে ?
āĻŦাāĻĒ্āĻĒি āĻĻাāĻĻু āĻিāĻুāĻ্āώāύ āĻŽāύāĻŽāϰা āĻšā§ে āĻŦāϏে āĻĨাāĻāϞো। āĻĒāϰāĻ্āώāĻŖেāĻ āϤাāϰ āĻŽুāĻে āĻšাāϏি āĻĢুāĻāϞো। āϏে āϤাāϰ āĻĢোāύ āĻšাāϤে āύিāϞো āĻāĻŦং āϤāϤāĻ্āώāύাā§ āĻĢোāύ āĻāϰāϞো āϤাāϰ āĻĒ্āϰিā§ āĻŦাāύ্āϧāĻŦী āĻŽাāĻāĻļাāĻে , āĻāĻŦং āĻŽাāĻāĻļাāϰ āĻাāĻ āĻĨেāĻে āϤাāϰ āĻšোāĻŽāĻā§াāϰ্āĻেāϰ āύোāĻ āĻাāϤাāĻুāϞো āĻেā§ে āύিāϞো। āϝাāϤে āϏে āϏেāĻি āĻāĻĒি āĻāϰে āĻুāĻŦ āϏāĻšāĻে āĻ āĻĻ্āϰুāϤ āĻšোāĻŽāĻā§াāϰ্āĻ āĻļেāώ āĻāϰāϤে āĻĒাāϰে। āĻāĻেāĻŦাāϰে āĻļুāϰু āĻĨেāĻে āĻĒ্āϰāϤ্āϝেāĻ āϏāĻŽāϏ্āϝাāϰ āϏāĻŽাāϧাāύ āĻāϰাāϰ āĻেā§ে āĻāĻে āĻĨেāĻে āĻŦাāύিā§ে āϰাāĻা āĻেāĻŽāĻĒ্āϞেāĻ āĻĻিā§ে āϏāĻŽাāϧাāύ āĻāϰা āϏāĻšāĻ āύা।
āĻŽāĻĄিāĻāϞেāϰ āĻāύāϏেāĻĒāĻিāĻ āĻāĻĒāύাāĻে āĻŦাāĻĒ্āĻĒি āĻĻাāĻĻুāϰ āĻŽāϤো āĻšāϤে āĻŦāϞে। Life is all about reusability, see?
āĻāĻ āĻšোāĻŽেāĻā§াāϰ্āĻেāϰ āĻŽāϤো āĻĒ্āϰোāĻ্āϰাāĻŽিংā§েāĻ āĻāĻĒāύি āϝে āĻĒ্āϰোāĻ্āϰাāĻŽāĻি āĻĄেāĻেāϞāĻĒ āĻāϰāϤে āĻাāĻāĻেāύ, āϏেāĻি āĻšā§āϤো āĻ āύ্āϝ āĻেāĻ āĻāϤিāĻŽāϧ্āϝে āϤৈāϰী āĻāϰে āĻĢেāϞেāĻে। āĻŦ্āϝাāϏ, āĻāĻĒāύাāϰ āĻাāĻ āĻāĻŽে āĻেāϞ। āĻāĻĒāύি āĻাāĻāϞেāĻ āĻ āύ্āϝ āĻাāϰো āϞেāĻা āĻোāĻĄ / āĻĒ্āϰোāĻ্āϰাāĻŽāĻুāϞো āĻāĻĒāύাāϰ āĻĒ্āϰāĻেāĻ্āĻেāϰ āĻŽāϧ্āϝে āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϤে āĻĒাāϰেāύ, āĻāĻে āĻĨেāĻে āϤৈāϰী āĻāϰে āϰাāĻা āĻāĻ āĻĒ্āϰোāĻ্āϰাāĻŽ āĻুāϞোāĻেāĻ āĻŦāϞা āĻšā§ āĻŽāĻĄিāĻāϞ (Modules) ।
āϏāĻšāĻāĻাāĻŦে āĻŦāϞāϞে, āĻŽāĻĄিāĻāϞ āĻšāϞো āĻāĻে āĻĨেāĻে āϤৈāϰী āĻāϰে āϰাāĻা āĻāĻāĻি āĻĢাāĻāϞ āϝাāϰ āĻŽāϧ্āϝে āĻāĻেāĻ āĻিāĻু āĻোāĻĄ āϞিāĻা(pre-written code) āĻĨাāĻে। āϝেāĻা globally available āĻāĻŦং āĻāĻĒāύি āĻāĻĒāύাāϰ āĻĒ্āϰā§োāĻāύ āĻ
āύুāϏাāϰে āĻāĻĒāύাāϰ āĻĒ্āϰোāĻ্āϰাāĻŽে āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϤে āĻĒাāϰেāύ। āĻŽāĻĄিāĻāϞ āĻāĻĒāύাāĻে āĻŦā§ো āĻāĻāĻি āĻĒ্āϰোāĻ্āϰাāĻŽāĻে āĻোāĻ āĻোāĻ āĻāύ্āĻĄে āĻাāĻ āĻāϰāϤে āϏাāĻšাāĻ্āϝ
āĻāϰāĻŦে।
āϝেāĻোāύো āĻĒাāĻāĻĨāύ āϏোāϰ্āϏ āĻĢাāĻāϞেāϰ āĻŽāϧ্āϝে āĻাāϏ্āĻ āĻāĻāĻি import āϏ্āĻেāĻāĻŽেāύ্āĻ(statement) āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰে, āĻ
āύ্āϝ āĻāĻāĻি āϏোāϰ্āϏ āĻĢাāĻāϞেāĻে āĻŽāĻĄিāĻāϞ āĻšিāϏেāĻŦে āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰা āϝাā§।
import āϏ্āĻেāĻāĻŽেāύ্āĻ āĻļুāϧু āĻŽাāϤ্āϰ āĻāĻ āĻŽāĻĄিāĻāϞেāϰ āϏāĻāϞ functionality āĻে āĻāĻŽাāĻĻেāϰ āĻĒ্āϰāĻেāĻ্āĻে āϝুāĻ্āϤ āĻāϰে āĻāĻŦং āĻāĻŽাāĻĻেāϰāĻে āĻāĻ āĻŽāĻĄিāĻāϞে āĻĨাāĻা āϝেāĻোāύো āĻĢাংāĻļāύ, āĻ্āϝাāϰিā§েāĻŦāϞ āĻŦা āĻ্āϞাāϏ āĻুāϞোāĻে āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϤে āĻĻেā§।
How to use a module?
ā§§. import āϏ্āĻেāĻāĻŽেāύ্āĻ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰে
āĻāĻ āĻĒāĻĻ্āϧāϤিāϤে āĻĒুāϰো āĻŽāĻĄিāĻāϞāĻিāĻে āĻāĻĒāύাāϰ āĻĒ্āϰোāĻ্āϰাāĻŽে āύিā§ে āĻāϏা āĻšā§। āĻŽāĻĄিāĻāϞেāϰ āĻেāϤāϰে āĻĨাāĻা āĻোāύো āĻĢাংāĻļāύ āĻŦা āĻ্āϝাāϰিā§েāĻŦāϞ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϤে āĻাāĻāϞে āĻĒ্āϰāĻĨāĻŽে āĻŽāĻĄিāĻāϞেāϰ āύাāĻŽ, āϤাāϰāĻĒāϰ āĻāĻāĻি āĻĄāĻ (.) āĻāĻŦং āϏāĻŦāĻļেāώে āĻĢাংāĻļāύেāϰ āύাāĻŽ āϞিāĻāϤে āĻšā§।
āϏিāύāĻ্āϝাāĻ্āϏ:
import module_nameāĻāĻĻাāĻšāϰāĻŖ:
import math
# math āĻŽāĻĄিāĻāϞেāϰ sqrt (square root āĻŦা āĻŦāϰ্āĻāĻŽূāϞ) āĻĢাংāĻļāύ āĻŦ্āϝāĻŦāĻšাāϰ
print(math.sqrt(16)) # āĻāĻāĻāĻĒুāĻ: 4.0
# math āĻŽāĻĄিāĻāϞেāϰ pi āĻāϰ āĻŽাāύ āĻĒ্āϰিāύ্āĻ āĻāϰা
print(math.pi) # āĻāĻāĻāĻĒুāĻ: 3.141592653589793⧍. as āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰে āĻŦা āĻ ্āϝাāϞিā§াāϏিং
āϝāĻĻি āĻŽāĻĄিāĻāϞেāϰ āύাāĻŽ āĻ
āύেāĻ āĻŦā§ āĻšā§ āĻŦা āĻোāĻĄ āϞেāĻাāϰ āϏুāĻŦিāϧাāϰ্āĻĨে āĻāĻĒāύি āĻŽāĻĄিāĻāϞāĻিāϰ āĻāĻāĻি āĻোāĻ āύাāĻŽ āĻĻিāϤে āĻাāύ, āϤāĻŦে as āĻিāĻā§াāϰ্āĻĄ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰা āĻšā§। āĻāĻে āĻāĻĒāύাāĻŽ āĻŦা āĻ
্āϝাāϞিā§াāϏ (Alias) āĻŦāϞা āĻšā§। āĻāϰ āĻĢāϞে āĻŽāĻĄিāĻāϞেāϰ āĻāϏāϞ āύাāĻŽেāϰ āĻĒāϰিāĻŦāϰ্āϤে āĻāĻĒāύাāϰ āĻĻেāĻā§া āĻোāĻ āύাāĻŽāĻি āĻĻিā§ে āĻাāĻ āĻāϰা āϝাā§।
āϏিāύāĻ্āϝাāĻ্āϏ:
import module_name as short_nameāĻāĻĻাāĻšāϰāĻŖ:
import math as m
# āĻāĻāύ 'math' āĻāϰ āĻŦāĻĻāϞে āĻļুāϧু 'm' āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϞেāĻ āĻšāĻŦে
print(m.sqrt(25)) # āĻāĻāĻāĻĒুāĻ: 5.0
print(m.pi) # āĻāĻāĻāĻĒুāĻ: 3.141592653589793ā§Š. from... import āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰে
āϝāĻĻি āĻāĻĒāύাāϰ āĻĒুāϰো āĻŽāĻĄিāĻāϞāĻিāϰ āĻĒ্āϰā§োāĻāύ āύা āĻĨাāĻে, āĻŦāϰং āĻŽāĻĄিāĻāϞ āĻĨেāĻে āύিāϰ্āĻĻিāώ্āĻ āĻোāύো āĻĢাংāĻļāύ āĻŦা āĻ্āϝাāϰিā§েāĻŦāϞ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϤে āĻাāύ, āϤāĻŦে āĻāĻ āĻĒāĻĻ্āϧāϤিāĻি āϏāĻŦāĻেā§ে āĻাāϰ্āϝāĻāϰ। āĻāĻ āĻĒāĻĻ্āϧāϤিāϰ āĻŦā§ āϏুāĻŦিāϧা āĻšāϞো, āĻোāĻĄ āϞেāĻাāϰ āϏāĻŽā§ āĻŦাāϰāĻŦাāϰ āĻŽāĻĄিāĻāϞেāϰ āύাāĻŽ āĻŦা āĻĄāĻ (.) āĻĻিāϤে āĻšā§ āύা, āϏāϰাāϏāϰি āĻĢাংāĻļāύেāϰ āύাāĻŽ āϞিāĻāϞেāĻ āĻাāĻ āĻāϰে।
āϏিāύāĻ্āϝাāĻ্āϏ:
from module_name import function_nameāĻāĻĻাāĻšāϰāĻŖ:
# math āĻŽāĻĄিāĻāϞ āĻĨেāĻে āĻļুāϧুāĻŽাāϤ্āϰ sqrt āĻāĻŦং pi-āĻে āĻāĻŽāĻĒোāϰ্āĻ āĻāϰা āĻšāϞো
from math import sqrt, pi
# āĻāĻāύ āϏāϰাāϏāϰি 'math.' āĻাā§াāĻ āĻāĻুāϞো āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰা āϝাāĻŦে
print(sqrt(9)) # āĻāĻāĻāĻĒুāĻ: 3.0
print(pi) # āĻāĻāĻāĻĒুāĻ: 3.141592653589793āĻāĻ āύāĻāϰে āϤিāύāĻি āĻĒāĻĻ্āϧāϤি:
| āĻĒāĻĻ্āϧāϤি | āϏিāύāĻ্āϝাāĻ্āϏ (Syntax) | āĻŦ্āϝāĻŦāĻšাāϰেāϰ āύিā§āĻŽ (Usage) |
|---|---|---|
| ā§§. import | import math | math.sqrt(16) |
| ⧍. as (Alias) | import math as m | m.sqrt(16) |
| ā§Š. from... import | from math import sqrt | sqrt(16) |
- āĻŽāĻĄিāĻāϞেāϰ āĻĒ্āϰāĻাāϰāĻেāĻĻ: āĻĒাāĻāĻĨāύে āĻŽূāϞāϤ āϤিāύ āϧāϰāύেāϰ āĻŽāĻĄিāĻāϞ āĻĨাāĻে:
- Built-in modules: āĻĒাāĻāĻĨāύেāϰ āϏাāĻĨে āĻāĻে āĻĨেāĻেāĻ āĻŦিāϞ্āĻ-āĻāύ āĻŦা āĻ āύ্āϤāϰ্āĻুāĻ্āϤ āĻĨাāĻে।
- Third-party modules: āĻāĻুāϞো āĻŦাāĻāϰেāϰ āĻŦা āĻ āύ্āϝাāύ্āϝ āĻĄেāĻেāϞāĻĒাāϰāĻĻেāϰ āϤৈāϰি āĻāϰা āĻŽāĻĄিāĻāϞ।
- Custom modules: āĻŦ্āϝāĻŦāĻšাāϰāĻাāϰী āύিāĻে āύিāĻেāϰ āĻĒ্āϰā§োāĻāύ āĻ āύুāϝাā§ী āĻāĻ āĻŽāĻĄিāĻāϞāĻুāϞো āϤৈāϰি āĻāϰেāύ।
Built-in Modules
āύāϤুāύ āĻāĻāĻি āĻĢোāύ āĻিāύāϞে āĻĻেāĻāĻŦেāύ, āϏেāĻ āĻĢোāύে āĻāĻে āĻĨেāĻেāĻ āĻŦেāĻļ āĻিāĻু āĻ
্āϝাāĻĒ āĻāύāϏ্āĻāϞ āĻāϰা āĻāĻে, āϝেāĻুāϞো āĻāĻĒāύি āύিāĻে āĻĨেāĻে āĻāύ্āϏāĻāϞ āĻāϰেāύāύি । āĻāĻ āϧāϰāύেāϰ āĻ
্āϝাāĻĒ āĻুāϞোāĻে āĻŦāϞে āĻŦিāϞ্āĻ āĻāύ āĻŽোāĻŦাāĻāϞ āĻ
্āϝাāĻĒ্āϞিāĻেāĻļāύ। āĻāĻ āĻ
্āϝাāĻĒ্āϞিāĻেāĻļāύāĻুāϞো āĻĻিāϝ়ে āĻāĻŽāϰা āĻāĻŽাāĻĻেāϰ āĻŦেāϏিāĻ āĻিāĻু āĻĒ্āϰāϝ়োāĻāύ āĻŽেāĻাāϤে āĻĒাāϰি, āϝেāĻŽāύ: āĻāύ্āĻাāϰāύেāĻ āĻŦ্āϰাāĻāĻিং, āĻāϞাāϰ্āĻŽ, āĻ্āϝাāϞāĻুāϞেāĻāϰ, āĻāϤ্āϝাāĻĻি। āĻāĻ āĻ
্āϝাāĻĒ্āϞিāĻেāĻļāύ āĻুāϞোāĻে āĻāĻĒāύি āĻāĻĒāύাāϰ āĻĒ্āϰāϝ়োāĻāύ āĻŽāϤ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϤে āĻĒাāϰেāύ।
āĻāĻāĻāĻাāĻŦে, āĻŦিāϞ্āĻ āĻāύ āĻŽāĻĄিāĻāϞ āĻšāϞো āĻĒাāĻāĻĨāύেāϰ āĻŽāϧ্āϝে āĻāĻে āĻĨেāĻেāĻ āĻĨাāĻা āĻিāĻু āĻŽāĻĄিāĻāϞ। āϝেāĻুāϞো āĻে āĻāϞাāĻĻা āĻāϰে āĻāύ্āϏāĻāϞ āĻāϰāϤে āĻšāϝ় āύা। āĻŦিāϞ্āĻ āĻāύ āĻŽāĻĄিāĻāϞ āĻুāϞো āϤাāĻ āϏāϰাāϏāϰি import āĻāϰে āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰা āϝাāϝ়।
āĻŦিāϞ্āĻ-āĻāύ (Built-in) āĻŽāĻĄিāĻāϞāĻুāϞো C āĻĒ্āϰোāĻ্āϰাāĻŽিং āĻাāώাāϝ় āϞেāĻা āĻāĻŦং Python Interpreter (Shell)-āĻāϰ āϏāĻ্āĻে āĻāĻীāĻূāϤ (integrated) āĻĨাāĻে। āĻĒ্āϰāϤিāĻি āĻŦিāϞ্āĻ-āĻāύ āĻŽāĻĄিāĻāϞে āύিāϰ্āĻĻিāώ্āĻ āĻিāĻু āϏিāϏ্āĻেāĻŽ-āύিāϰ্āĻāϰ (system-specific) āĻাāĻেāϰ āĻāύ্āϝ āĻĒ্āϰāϝ়োāĻāύীāϝ় āĻĢাংāĻļāύ āĻ āϰিāϏোāϰ্āϏ āĻĨাāĻে।
Python-āĻ āĻāĻĒāϞāĻŦ্āϧ āϏāĻŦ āĻŦিāϞ্āĻ-āĻāύ āĻŽāĻĄিāĻāϞেāϰ āϤাāϞিāĻা āĻĻেāĻāϤে Python Console-āĻ āύিāĻেāϰ āĻāĻŽাāύ্āĻĄāĻি āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϤে āĻĒাāϰেāύ:
help('modules')
Working with Built in Modules
Math
āĻāĻŖিāϤ āĻāĻŦং āĻŦিāĻিāύ্āύ āĻāĻŖāύা āĻāϰা āĻĒ্āϰোāĻ্āϰাāĻŽিং āĻāĻŦং āĻāĻŽাāĻĻেāϰ āĻĻৈāύāύ্āĻĻিāύ āĻীāĻŦāύেāϰ āĻāĻāĻি āĻ āĻŦিāĻ্āĻেāĻĻ্āϝ āĻ ংāĻļ। āĻāĻŽāϰা āϝেāĻŽāύ āĻাāύি, āĻŦিāĻিāύ্āύ āĻāĻŖāύা āĻāϰাāϰ āĻāύ্āϝ āĻāĻŽāϰা āĻĒাāĻāĻĨāύ (Python) āĻĻ্āĻŦাāϰা āĻĻেāĻā§া āĻŦিāĻিāύ্āύ āĻ āĻĒাāϰেāĻāϰ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϤে āĻĒাāϰি। āĻিāύ্āϤু, āĻāĻŽāύ āĻĒāϰিāϏ্āĻĨিāϤিāĻ āĻāϏে āϝāĻāύ āĻāĻিāĻ āϝāĻĨেāώ্āĻ āύāϝ়!āύীāĻেāϰ āĻāĻĻাāĻšāϰāĻŖāĻি āĻŦিāĻŦেāĻāύা āĻāϰুāύ,āϧāϰে āύিāύ āĻāĻĒāύাāϰ āĻāĻāĻি āύিāϰ্āĻĻিāώ্āĻ āϏংāĻ্āϝাāϰ āĻĢ্āϝাāĻ্āĻোāϰিāϝ়াāϞ (Factorial) āĻāĻŖāύা āĻāϰা āĻĒ্āϰāϝ়োāĻāύ (āĻĢ্āϝাāĻ্āĻোāϰিāϝ়াāϞ āĻšāϞো āĻāĻāĻি āύিāϰ্āĻĻিāώ্āĻ āϧāύাāϤ্āĻŽāĻ āĻĒূāϰ্āĻŖāϏংāĻ্āϝাāϰ āϏāĻŽাāύ āĻŦা āϤাāϰ āĻেāϝ়ে āĻোāĻ āϏāĻŽāϏ্āϤ āϧāύাāϤ্āĻŽāĻ āĻĒূāϰ্āĻŖāϏংāĻ্āϝাāϰ āĻুāĻŖāĻĢāϞ)। āĻāĻĻাāĻšāϰāĻŖāϏ্āĻŦāϰূāĻĒ, ā§Ģ (5) āĻāϰ āĻĢ্āϝাāĻ্āĻোāϰিāϝ়াāϞ āĻšāĻŦে 5*4*3*2*1 āϝাāϰ āĻĢāϞাāĻĢāϞ āĻšāĻŦে 120।
āĻāĻ āϏāĻŽāϏ্āϝা āϏāĻŽাāϧাāύেāϰ āĻāύ্āϝ āύিāĻে āĻĨেāĻে āĻোāĻĄ āϞেāĻা āĻুāĻŦ āĻāĻāĻা āĻāĻ িāύ āύāϝ়, āĻিāύ্āϤু āĻāĻা āĻ āĻŦāĻļ্āϝāĻ āϏāĻŽāϝ় āϏাāĻĒেāĻ্āώ āĻŦিāώāϝ়। āĻāĻাāύেāĻ āĻāĻĒāύাāϰ āĻাāĻে āϞাāĻāĻŦে Math Module.
Math āĻŽāĻĄিāĻāϞ āĻšāϞো āĻĒাāĻāĻĨāύেāϰ āĻāĻāĻি āĻŦিāϞ্āĻ-āĻāύ āĻŽāĻĄিāĻāϞ āϝেāĻি āĻĻ্āĻŦাāϰা mathematical functions āĻুāϞোāϰ āĻ ্āϝাāĻ্āϏেāϏ āύেāĻāϝ়া āϝাāϝ়। āϝেāĻšেāϤু āĻāĻি āĻāĻāĻি āĻŦিāϞ্āĻ-āĻāύ āĻŽāĻĄিāĻāϞ āϤাāĻ āĻāĻি āϏāϰাāϏāϰি import āĻāϰা āϝাāϝ়, āĻāĻ āϏ্āĻেāĻāĻŽেāύ্āĻāĻি āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰে:
import mathāύিāĻে āĻŽ্āϝাāĻĨ (math) āĻŽāĻĄিāĻāϞেāϰ āĻিāĻু āϏাāϧাāϰāĻŖ āĻāĻŦং āϏাāϧাāϰāĻŖāϤ āĻŦ্āϝāĻŦāĻšৃāϤ āĻĢাংāĻļāύ āĻĻেāĻā§া āĻšāϞো,
- floor(value) - āĻāĻি āĻĒ্āϰāĻĻāϤ্āϤ āĻŽাāύেāϰ āĻেā§ে āĻোāĻ āĻ āĻĨāĻŦা āϏāĻŽাāύ āϏāĻŦāĻেā§ে āĻŦā§ āĻĒূāϰ্āĻŖāϏংāĻ্āϝাāĻি āϰিāĻাāϰ্āύ āĻāϰে।
- ceil(value) - āĻāĻি āĻĒ্āϰāĻĻāϤ্āϤ āĻŽাāύেāϰ āĻেā§ে āĻŦā§ āĻ āĻĨāĻŦা āϏāĻŽাāύ āϏāĻŦāĻেā§ে āĻোāĻ āĻĒূāϰ্āĻŖāϏংāĻ্āϝাāĻি āϰিāĻাāϰ্āύ āĻāϰে।
- factorial(value) - āĻāĻি āĻĒ্āϰāĻĻāϤ্āϤ āĻŽাāύেāϰ āĻĢ্āϝাāĻ্āĻোāϰিā§াāϞ āϰিāĻাāϰ্āύ āĻāϰে।
- fabs(value) - āĻāĻি āĻĒ্āϰāĻĻāϤ্āϤ āĻŽাāύেāϰ āĻĒāϰāĻŽ āĻŽাāύ (absolute value) āϰিāĻাāϰ্āύ āĻāϰে।
- sqrt(value) - āĻāĻি āĻĒ্āϰāĻĻāϤ্āϤ āĻŽাāύেāϰ āĻŦāϰ্āĻāĻŽূāϞ (square root) āϰিāĻাāϰ্āύ āĻāϰে।
āĻāϞুāύ āĻāĻŦাāϰ āϏাāĻŽāύে āĻāĻিā§ে āϝাāĻ āĻāĻŦং āĻāĻ āĻĢাংāĻļāύāĻুāϞো āĻĒ্āϰā§োāĻ āĻāϰাāϰ āĻেāώ্āĻা āĻāϰি।
import math
number1 = 4
number2 = 2.5
print(math.sqrt(number1))
print(math.floor(number2))
print(math.ceil(number2))
print(math.factorial(number1))
print(math.fabs(number2))āĻāϞুāύ math āĻŽāĻĄিāĻāϞ āĻĻ্āĻŦাāϰা āĻĒ্āϰāĻĻাāύ āĻāϰা āĻāϰāĻ āĻিāĻু āĻĢাংāĻļāύ āĻĻেāĻে āύেāĻā§া āϝাāĻ, āϝাāϰ āĻŽāϧ্āϝে āĻিāĻু āϤ্āϰিāĻোāĻŖāĻŽিāϤি āĻāĻŦং āϞāĻাāϰিāĻĻāĻŽ āϏāĻŽ্āĻĒāϰ্āĻিāϤ āĻĢাংāĻļāύāĻ āϰā§েāĻে:
- log2(value) - āĻāĻি āĻĒ্āϰāĻĻāϤ্āϤ āĻ্āϝাāϞুāϰ āĻŦেāϏ ⧍ (base 2) āĻāϰ āϞāĻ āϰিāĻাāϰ্āύ āĻāϰে।
- log10(value) - āĻāĻি āĻĒ্āϰāĻĻāϤ্āϤ āĻ্āϝাāϞুāϰ āĻŦেāϏ ā§§ā§Ļ (base 10) āĻāϰ āϞāĻ āϰিāĻাāϰ্āύ āĻāϰে।
- pow(num1, num2) - āĻāĻি num1 āĻāϰ āĻĒাāĻā§াāϰ num2 āϰিāĻাāϰ্āύ āĻāϰে।
- sin(value) - āĻāĻি āϰেāĻĄিāϝ়াāύে (radians) āĻĒ্āϰāĻĻāϤ্āϤ āĻ্āϝাāϞুāϰ āϏাāĻāύ (sine) āϰিāĻাāϰ্āύ āĻāϰে।
- cos(value) - āĻāĻি āϰেāĻĄিāϝ়াāύে āĻĒ্āϰāĻĻāϤ্āϤ āĻ্āϝাāϞুāϰ āĻোāϏাāĻāύ (cosine) āϰিāĻাāϰ্āύ āĻāϰে।
- tan(value) - āĻāĻি āϰেāĻĄিāϝ়াāύে āĻĒ্āϰāĻĻāϤ্āϤ āĻ্āϝাāϞুāϰ āĻ্āϝাāύāĻেāύ্āĻ (tangent) āϰিāĻাāϰ্āύ āĻāϰে।
āĻāĻāύ āĻāϞুāύ āϏাāĻŽāύে āĻāĻিā§ে āϝাāĻā§া āϝাāĻ āĻāĻŦং āĻāϰ āĻŽāϧ্āϝে āĻā§েāĻāĻি āĻĢাংāĻļāύ āĻāĻŽāĻĒ্āϞিāĻŽেāύ্āĻ āĻāϰাāϰ āĻেāώ্āĻা āĻāϰি।
import math
number1 = 4
number2 = 2
print(math.log10(number1))
print(math.sin(number1))
print(math.pow(number1, number2))
Random
āĻĒাāĻāĻĨāύে āĻāĻŽāϰা āĻ āĻĒāϰ্āϝāύ্āϤ āĻĻেāĻেāĻি āϝে āϏাāϧাāϰāĻŖ āĻ
āĻĒাāϰেāĻāϰ āĻāĻŦং math āĻŽāĻĄিāĻāϞ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰে āϏংāĻ্āϝাāϰ āĻāĻĒāϰ āĻŦিāĻিāύ্āύ āϧāϰāύেāϰ āĻাāĻŖিāϤিāĻ āĻাāĻ āĻŦা āĻ
āĻĒাāϰেāĻļāύ āĻāϰা āϝাā§। āϤা āϏāϤ্āϤ্āĻŦেāĻ, āĻāĻŽāύ āĻিāĻু āĻĒāϰিāϏ্āĻĨিāϤি āϤৈāϰি āĻšā§ āϝāĻāύ āĻāĻŽাāĻĻেāϰ āĻ
্āϝাāĻĒ্āϞিāĻেāĻļāύে āĻোāύো āύিāϰ্āĻĻিāώ্āĻ āύিā§āĻŽ āĻাā§া āĻšāĻ াā§ āĻāϰে āĻŦা āĻāϞোāĻŽেāϞো āĻিāĻু āϏংāĻ্āϝা āϤৈāϰি āĻāϰাāϰ āĻĒ্āϰā§োāĻāύ āĻĒā§ে— āϝেāĻŽāύ āĻāĻিāĻĒি (OTP) āĻŦা āĻ্āϰাāύāĻেāĻāĻļāύ āĻāĻāĻĄি (Transaction ID) āĻāĻŦং āĻāϰāĻ āĻ
āύেāĻ āĻিāĻু।
āϤাāĻ āϝেāĻোāύো āĻ
্āϝাāĻĒ্āϞিāĻেāĻļāύেāϰ āĻāύ্āϝāĻ āϏংāĻ্āϝা āĻāĻāĻি āĻ
āĻŦিāĻ্āĻেāĻĻ্āϝ āĻ
ংāĻļ, āĻāĻŦং āĻĒাāĻāĻĨāύে āĻāĻ āĻাāĻāĻুāϞো āĻāϰাāϰ āĻāύ্āϝ āĻŦিāĻিāύ্āύ āĻŽāĻĄিāĻāϞ āĻĻেāĻā§া āĻāĻে। āϤেāĻŽāύāĻ āĻāĻāĻি āĻŽāĻĄিāĻāϞ āĻšāϞো āĻĒাāĻāĻĨāύেāϰ random āĻŽāĻĄিāĻāϞ.
āϰ্āϝাāύ্āĻĄāĻŽ āĻŽāĻĄিāĻāϞ (Random Module)
random āĻŽāĻĄিāĻāϞ āĻšāϞো āĻĒাāĻāĻĨāύেāϰ āĻāĻāĻি āĻŦিāϞ্āĻ-āĻāύ (āĻāĻে āĻĨেāĻেāĻ āϤৈāϰি āĻāϰে āϰাāĻা) āĻŽāĻĄিāĻāϞ, āϝা pseudo-random (āĻāĻĻ্āĻŽ-āĻāϞোāĻŽেāϞো āĻŦা āĻāĻĒাāϤ-āĻ
āύিāϰ্āϧাāϰিāϤ) āĻেāϰিā§েāĻŦāϞ āϤৈāϰি āĻāϰāϤে āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰা āĻšā§। āĻāϞোāĻŽেāϞোāĻাāĻŦে āĻŦা āĻšāĻ াā§ āĻোāύো āĻাāĻ āĻāϰাāϰ āĻāύ্āϝ āĻāĻি āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰা āϝেāϤে āĻĒাāϰে; āϝেāĻŽāύ— āĻোāύো āϰ্āϝাāύ্āĻĄāĻŽ āĻŦা āĻāϞোāĻŽেāϞো āϏংāĻ্āϝা āύেāĻā§া, āĻāĻāĻি āϞিāϏ্āĻ (list) āĻĨেāĻে āϝেāĻোāύো āĻāĻĒাāĻĻাāύ āĻŦেāĻে āύেāĻā§া, āϞিāϏ্āĻেāϰ āĻāĻĒাāĻĻাāύāĻুāϞোāĻে āĻāϞāĻāĻĒাāϞāĻ (shuffle) āĻāϰা āĻāϤ্āϝাāĻĻি।
āϤাāĻ āϏāĻšāĻ āĻāĻĨাā§ āĻŦāϞāϤে āĻেāϞে, āϰ্āϝাāύ্āĻĄāĻŽ āĻŽāĻĄিāĻāϞ āĻšāϞো āĻāĻŽāύ āĻিāĻু āĻĢাংāĻļāύেāϰ āϏāĻŽāώ্āĻি, āϝা āĻāϞোāĻŽেāϞো āϏংāĻ্āϝা āϤৈāϰি āĻāϰāϤে āĻŦা āϏেāĻুāϞোāĻে āĻāĻŽাāĻĻেāϰ āĻĒ্āϰā§োāĻāύāĻŽāϤো āύিā§āύ্āϤ্āϰāĻŖ āĻāϰāϤে āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰা āĻšā§। āϝেāĻšেāϤু āĻāĻি āĻāĻāĻি āĻŦিāϞ্āĻ-āĻāύ āĻŽāĻĄিāĻāϞ, āϤাāĻ āĻāĻŽāϰা āύিāĻেāϰ āϏ্āĻেāĻāĻŽেāύ্āĻāĻি āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰে āϏāϰাāϏāϰি āĻāĻিāĻে āĻāĻŽ্āĻĒোāϰ্āĻ (import) āĻāϰে āĻাāĻ āĻļুāϰু āĻāϰāϤে āĻĒাāϰি:
import randomāĻāϞো random āĻŽāĻĄিāĻāϞেāϰ āϏাāϧাāϰāĻŖāϤ āĻŦ্āϝāĻŦāĻšৃāϤ āĻā§েāĻāĻি āĻŽেāĻĨāĻĄ āĻŦা āĻĢাংāĻļāύ āĻĻেāĻে āύেāĻā§া āϝাāĻ:
ā§§) random()
āĻāĻি 0.0 āĻĨেāĻে 1.0-āĻāϰ āĻŽāϧ্āϝে āϝেāĻোāύো āĻāĻāĻি āĻāϞোāĻŽেāϞো āĻŦা āϰ্āϝাāύ্āĻĄāĻŽ āĻĻāĻļāĻŽিāĻ āϏংāĻ্āϝা (float number) āĻāĻāĻāĻĒুāĻ āĻšিāϏেāĻŦে āĻĻেā§।
āĻŽāύে āϰেāĻো: āϝāϤāĻŦাāϰāĻ āϤুāĻŽি āĻāĻ āĻোāĻĄāĻি āϰাāύ (execute) āĻāϰāĻŦে, āĻĒ্āϰāϤিāĻŦাāϰāĻ āĻāĻāĻি āĻিāύ্āύ āĻিāύ্āύ āϰ্āϝাāύ্āĻĄāĻŽ āϏংāĻ্āϝা āĻĒাāĻā§াāϰ āϏāĻŽ্āĻাāĻŦāύা āĻĨাāĻে।
⧍) randint(x, y)
āĻāĻি āϤোāĻŽাāϰ āĻŦāϞে āĻĻেāĻā§া āύিāϰ্āĻĻিāώ্āĻ āϏীāĻŽাāϰ (x āĻāĻŦং y) āĻŽāϧ্āϝে āĻĨেāĻে āϝেāĻোāύো āĻāĻāĻি āϰ্āϝাāύ্āĻĄāĻŽ āĻĒূāϰ্āĻŖāϏংāĻ্āϝা (integer) āĻāĻāĻāĻĒুāĻ āĻĻেā§। āĻāĻাāύে x āĻāĻŦং y āĻĻুāĻো āϏংāĻ্āϝাāĻ āĻ āύ্āϤāϰ্āĻুāĻ্āϤ āĻĨাāĻে।
ā§Š) randrange(start, stop, step)
āĻāĻি start, stop, āĻāĻŦং step āĻāϰ্āĻুāĻŽেāύ্āĻāĻুāϞোāϰ āĻŽাāϧ্āϝāĻŽে āϤৈāϰি āĻāϰা āĻāĻāĻি āύিāϰ্āĻĻিāώ্āĻ āϰেāĻ্āĻ āĻŦা āϏীāĻŽা āĻĨেāĻে āĻāϞোāĻŽেāϞোāĻাāĻŦে āĻāĻāĻি āϏংāĻ্āϝা āĻŦেāĻে āύেā§।
- āĻāĻাāύে āĻĄিāĻĢāϞ্āĻ āĻŦা āϏ্āĻŦā§ংāĻ্āϰিā§āĻাāĻŦে start-āĻāϰ āĻŽাāύ āĻĨাāĻে 0।
- āĻāĻāĻāĻাāĻŦে, āĻĄিāĻĢāϞ্āĻāĻাāĻŦে step-āĻāϰ āĻŽাāύ āĻĨাāĻে 1।
# āĻāĻĻাāĻšāϰāĻŖ ā§§ (Example 1)
import random
print(random.random())
# āĻāĻি ā§Ļ.ā§Ļ āĻĨেāĻে ā§§.ā§Ļ āĻāϰ āĻŽāϧ্āϝে āĻāĻāĻি āĻĻāĻļāĻŽিāĻ āϏংāĻ্āϝা āĻĒ্āϰিāύ্āĻ āĻāϰāĻŦে।
# āĻāĻĻাāĻšāϰāĻŖ ⧍ (Example 2)
import random
print(random.randint(1, 6))
# āĻāĻি ā§§ āĻĨেāĻে ā§Ŧ āĻāϰ āĻŽāϧ্āϝে āϝেāĻোāύো āĻāĻāĻি āĻĒূāϰ্āĻŖāϏংāĻ্āϝা (āϝেāĻŽāύ: āϞুāĻĄুāϰ āĻāĻ্āĻাāϰ āĻŽāϤো ā§§, ⧍, ā§Š, ā§Ē, ā§Ģ āĻŦা ā§Ŧ) āĻĒ্āϰিāύ্āĻ āĻāϰāĻŦে।
# āĻāĻĻাāĻšāϰāĻŖ ā§Š (Example 3)
import random
print(random.randrange(1, 6, 2))
# āĻāĻি ā§§ āĻĨেāĻে āĻļুāϰু āĻāϰে ā§Ŧ āĻāϰ āĻāĻ āĻĒāϰ্āϝāύ্āϤ ⧍ āĻāϰ āĻĒāϰ āĻĒāϰ āϞাāĻĢিā§ে (āϝেāĻŽāύ: ā§§, ā§Š, ā§Ģ) āϝেāĻোāύো āĻāĻāĻি āĻŦিāĻোā§ āϏংāĻ্āϝা āĻĒ্āϰিāύ্āĻ āĻāϰāĻŦে।
āϰ্āϝাāύ্āĻĄāĻŽ āĻāĻĒাāĻĻাāύ āĻŦা āĻāϞিāĻŽেāύ্āĻ (Random Elements)
āĻāĻŦাāϰ āĻāϞো āĻāĻŽāύ āĻিāĻু āĻŽেāĻĨāĻĄ āĻŦা āĻĢাংāĻļāύ āĻĻেāĻে āύেāĻā§া āϝাāĻ, āϝা āĻোāύো āĻāĻāĻি āĻাāϞেāĻāĻļāύ āĻŦা āĻĄাāĻাāϰ āĻ্āϰুāĻĒ (āϝেāĻŽāύ: āĻāĻāĻি āϞিāϏ্āĻ) āĻĨেāĻে āĻāϞোāĻŽেāϞোāĻাāĻŦে āĻĄাāĻা āϤৈāϰি āĻāϰāϤে āĻŦা āĻŦেāĻে āύিāϤে āϏাāĻšাāϝ্āϝ āĻāϰে:
ā§§) choice(sequence)
āĻāĻি āĻোāύো āĻāĻāĻি āĻাāϞি āύ⧠āĻāĻŽāύ āϏিāĻোā§েāύ্āϏ āĻŦা āϞিāϏ্āĻ āĻĨেāĻে āĻāϞোāĻŽেāϞোāĻাāĻŦে āϝেāĻোāύো āĻāĻāĻি āĻāĻĒাāĻĻাāύ (element) āĻŦেāĻে āύিā§ে āϤা āĻāĻāĻāĻĒুāĻ āĻšিāϏেāĻŦে āĻĻেāĻাā§।
⧍) shuffle(sequence)
āĻāĻি āĻোāύো āĻāĻāĻি āϏিāĻোā§েāύ্āϏ āĻŦা āϞিāϏ্āĻেāϰ āĻেāϤāϰে āĻĨাāĻা āĻāĻĒাāĻĻাāύāĻুāϞোāϰ āĻ্āϰāĻŽ āĻŦা āϏিāϰিā§াāϞāĻে āϏāĻŽ্āĻĒূāϰ্āĻŖ āĻāϞোāĻŽেāϞোāĻাāĻŦে āĻāϞāĻāĻĒাāϞāĻ (reorder) āĻāϰে āĻĻেā§।
āύিāĻে āĻāϰ āĻāĻāĻি āĻāĻĻাāĻšāϰāĻŖ āĻĻেāĻā§া āĻšāϞো:
import random
# āĻāĻাāύে ā§§ āĻĨেāĻে ā§Ŧ āĻĒāϰ্āϝāύ্āϤ āϏংāĻ্āϝাāϰ āĻāĻāĻি āϞিāϏ্āĻ āϤৈāϰি āĻāϰা āĻšā§েāĻে
numbers = [1, 2, 3, 4, 5, 6]
# ā§§) choice āĻŦ্āϝāĻŦāĻšাāϰ: āĻāĻি āĻāĻ āϞিāϏ্āĻ āĻĨেāĻে āϝেāĻোāύো āĻāĻāĻি āϏংāĻ্āϝা (āϝেāĻŽāύ: ā§Ē) āĻŦেāĻে āύিā§ে āĻĒ্āϰিāύ্āĻ āĻāϰāĻŦে
print(random.choice(numbers))
# ⧍) shuffle āĻŦ্āϝāĻŦāĻšাāϰ: āĻāĻি āĻŽূāϞ āϞিāϏ্āĻেāϰ āĻেāϤāϰেāϰ āϏংāĻ্āϝাāĻুāϞোāĻে āĻāϞāĻāĻĒাāϞāĻ āĻāϰে āĻĻেāĻŦে
random.shuffle(numbers)
# āĻāϞāĻāĻĒাāϞāĻ āĻāϰাāϰ āĻĒāϰ āĻĒুāϰো āϞিāϏ্āĻāĻি āĻেāĻŽāύ āĻĻেāĻাāĻŦে āϤা āĻĒ্āϰিāύ্āĻ āĻāϰা āĻšāĻ্āĻে
print(numbers)
# āĻāĻāĻāĻĒুāĻāĻি āĻšāϤে āĻĒাāϰে āĻāĻŽāύ: [ā§Š, ā§§, ā§Ģ, ⧍, ā§Ŧ, ā§Ē] (āĻĒ্āϰāϤিāĻŦাāϰ āϰাāύ āĻāϰāϞে āĻāĻি āĻāϞাāĻĻা āĻšāϤে āĻĒাāϰে)
OS
āĻāĻāĻি āĻ āĻĒাāϰেāĻিং āϏিāϏ্āĻেāĻŽ āĻšāĻ্āĻে āĻāĻŽ্āĻĒিāĻāĻাāϰ āĻāĻāĻাāϰ āĻāĻŦং āĻāĻŽ্āĻĒিāĻāĻাāϰ āĻšাāϰ্āĻĄāĻāϝ়াāϰ āĻāϰ āĻŽāϧ্āϝে āĻĨাāĻা āĻāĻāĻি āĻāύ্āĻাāϰāĻĢেāϏ। āĻ āĻĒাāϰেāĻিং āϏিāϏ্āĻেāĻŽ āĻšāĻ্āĻে āĻāĻŽāύ āĻāĻāĻি āϏāĻĢāĻāĻāϝ়্āϝাāϰ āϝেāĻি āϏāĻāϞ āϧāϰāύেāϰ āĻŦেāϏিāĻ āĻাāϏ্āĻ āĻুāϞো āϏāĻŽ্āĻĒাāĻĻāύ āĻāϰে, āϝেāĻŽāύ: āĻĢাāĻāϞ āĻŽ্āϝাāύেāĻāĻŽেāύ্āĻ, āĻŽেāĻŽোāϰি āĻŽ্āϝাāύেāĻāĻŽেāύ্āĻ, āĻĒ্āϰāϏেāϏ āĻŽ্āϝাāύেāĻāĻŽেāύ্āĻ, āĻāύāĻĒুāĻ āĻ āĻāĻāĻāĻĒুāĻ āĻš্āϝাāύ্āĻĄেāϞিং, peripheral device (āϝেāĻŽāύ āĻĒ্āϰিāύ্āĻাāϰ, āĻĄিāϏ্āĻ āĻĄ্āϰাāĻāĻ) āĻāύ্āĻ্āϰোāϞ āĻāϤ্āϝাāĻĻি।
āĻĒ্āϰোāĻ্āϰাāĻŽিং āĻাāώাāϰ āĻ āύ্āϝāϤāĻŽ āĻāĻāĻি āĻĒ্āϰāϧাāύ āĻাāĻ āĻšāϞো āĻāĻŽ্āĻĒিāĻāĻাāϰেāϰ āϏাāĻĨে OS Level āĻ āϝোāĻাāϝোāĻ āĻāϰা। āĻāĻা āĻāϰো āĻŦেāĻļি āĻāύ্āĻ্āϰোāϞ, āĻ ্āϝাāĻ্āϏেāϏ āĻāĻŦং āĻĢাংāĻļāύাāϞিāĻিāĻে āĻāύ্āĻŽুāĻ্āϤ āĻāϰে āĻĻেāϝ়।
OS Module
āĻĒাāĻāĻĨāύেāϰ āϝāĻĻিāĻ āϏāϰাāϏāϰি āĻ
āĻĒাāϰেāĻিং āϏিāϏ্āĻেāĻŽ āϞেāĻেāϞেāϰ āĻĢাংāĻļāύাāϞিāĻিāϰ āĻāĻĒāϰ āĻ
্āϝাāĻ্āϏেāϏ āύেāĻ, āϤāĻŦে āĻŦিāĻāϞ্āĻĒ āĻšিāϏেāĻŦে āϰāϝ়েāĻে OS module.
āĻāĻ OS āĻŽāĻĄিāĻāϞ āĻĻ্āĻŦাāϰা āĻāĻŽāϰা āĻāĻāĻাāϰ āĻāĻŦং āĻ
āĻĒাāϰেāĻিং āϏিāϏ্āĻেāĻŽেāϰ āĻŽāϧ্āϝে āϝোāĻাāϝোāĻ āϏাāϧāύ āĻāϰāϤে āĻĒাāϰি। āϝেāĻšেāϤু āĻāĻি āĻāĻāĻি āĻŦিāϞ্āĻ-āĻāύ āĻŽāĻĄিāĻāϞ, āϤাāĻ āύিāĻেāϰ āϏ্āĻেāĻāĻŽেāύ্āĻেāϰ āĻŽাāϧ্āϝāĻŽে āĻāĻŽāϰা āĻāĻি āĻে āϏāϰাāϏāϰি import āĻāϰāϤে āĻĒাāϰি :
import osāĻāĻāϏ āĻŽāĻĄিāĻāϞেāϰ āĻাāĻ
āĻāϞো āĻāĻŦাāϰ os āĻŽāĻĄিāĻāϞেāϰ āĻā§েāĻāĻি āĻĢাংāĻļāύ āĻāĻŦং āĻ ্āϝাāĻ্āϰিāĻŦিāĻāĻ (attribute) āĻĻেāĻে āύেāĻā§া āϝাāĻ āĻāĻŦং āĻļিāĻি āĻীāĻাāĻŦে āĻĒাāĻāĻĨāύ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰে āĻāĻŽাāĻĻেāϰ āĻāĻŽ্āĻĒিāĻāĻাāϰেāϰ āĻ āĻĒাāϰেāĻিং āϏিāϏ্āĻেāĻŽ āϞেāĻেāϞেāϰ āĻাāĻāĻুāϞো āύিā§āύ্āϤ্āϰāĻŖ āĻāϰা āϝাā§।
ā§§) os.name -
āĻāĻি āĻĒাāĻāĻĨāύ āϝে āĻ āĻĒাāϰেāĻিং āϏিāϏ্āĻেāĻŽ āĻŽāĻĄিāĻāϞāĻি āĻāĻŽ্āĻĒোāϰ্āĻ āĻāϰেāĻে, āϤাāϰ āύাāĻŽ āϰিāĻাāϰ্āύ āĻŦা āĻāĻāĻāĻĒুāĻ āĻāϰে।
āĻŽāύে āϰেāĻো: āĻāĻি āĻিāύ্āϤু āĻোāύো āĻĢাংāĻļāύ āύ⧠(āϤাāĻ āĻāϰ āĻļেāώে āĻŦ্āϰ্āϝাāĻেāĻ () āĻĨাāĻে āύা), āĻāĻি āĻšāϞো os āĻŽāĻĄিāĻāϞেāϰ āĻেāϤāϰে āĻĨাāĻা āĻāĻāĻি āĻেāϰিā§েāĻŦāϞ āĻŦা āĻ ্āϝাāĻ্āϰিāĻŦিāĻāĻ। āϝেāĻŽāύ: āĻāĻāύ্āĻĄোāĻ āĻāĻŽ্āĻĒিāĻāĻাāϰে āĻāĻি āϏাāϧাāϰāĻŖāϤ 'nt' āĻāĻāĻāĻĒুāĻ āĻĻেā§।
⧍) os.getcwd() -
āĻāĻি āϤোāĻŽাāϰ āĻŦāϰ্āϤāĻŽাāύে āĻāϞāĻŽাāύ āĻĢাāĻāϞāĻি āĻāĻŽ্āĻĒিāĻāĻাāϰেāϰ āĻোāύ āĻĄিāϰেāĻ্āĻāϰি āĻŦা āĻĢোāϞ্āĻĄাāϰে āĻāĻে (Current Working Directory - CWD), āϏেāĻ āĻĒুāϰো āϞোāĻেāĻļāύ āĻŦা āĻĒাāĻĨ (path)āĻি āĻāĻāĻāĻĒুāĻ āĻšিāϏেāĻŦে āĻĻেāĻাā§।
āĻŽāύে āϰেāĻো: āĻāĻŽ্āĻĒিāĻāĻাāϰ āĻāĻŦং āĻĢোāϞ্āĻĄাāϰেāϰ āύাāĻŽāĻেāĻĻে āĻāĻ āĻāĻāĻāĻĒুāĻāĻি āĻāĻেāĻ āϏিāϏ্āĻেāĻŽে āĻāĻেāĻ āϰāĻāĻŽ āĻšāϤে āĻĒাāϰে।
# āĻāĻĻাāĻšāϰāĻŖ ā§§ (Example 1)
import os
print(os.name)
# āĻāĻি āϤোāĻŽাāϰ āĻ
āĻĒাāϰেāĻিং āϏিāϏ্āĻেāĻŽেāϰ āϏংāĻ্āώিāĻĒ্āϤ āύাāĻŽ (āϝেāĻŽāύ: 'nt' āĻŦা 'posix') āĻĒ্āϰিāύ্āĻ āĻāϰāĻŦে।
# āĻāĻĻাāĻšāϰāĻŖ ⧍ (Example 2)
import os
print(os.getcwd())
# āĻāĻি āĻŦāϰ্āϤāĻŽাāύে āϤুāĻŽি āϝে āĻĢোāϞ্āĻĄাāϰে āĻাāĻ āĻāϰāĻ, āϤাāϰ āϏāĻŽ্āĻĒূāϰ্āĻŖ āĻ িāĻাāύা (āϝেāĻŽāύ: C:\Users\Name\Documents) āĻĒ্āϰিāύ্āĻ āĻāϰāĻŦে।
ā§Š) os.mkdir() -
āĻāĻ āĻĢাংāĻļāύāĻি āĻāĻŽ্āĻĒিāĻāĻাāϰে āĻāĻāĻি āύāϤুāύ āĻĄিāϰেāĻ্āĻāϰি āĻŦা āĻĢোāϞ্āĻĄাāϰ āϤৈāϰি āĻāϰāϤে āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰা āĻšā§। āĻĢাংāĻļāύāĻিāϰ āĻেāϤāϰে āϏ্āĻ্āϰিং (string) āĻšিāϏেāĻŦে āϤুāĻŽি āϝে āĻ িāĻাāύা āĻŦা āĻĒাāĻĨ (path) āϞিāĻে āĻĻেāĻŦে, āĻ িāĻ āϏেāĻ āĻাā§āĻাā§ āĻāĻি āύāϤুāύ āĻĢোāϞ্āĻĄাāϰāĻি āϤৈāϰি āĻāϰāĻŦে।
import os
os.mkdir("D:\\programming")
# āĻāĻ āĻোāĻĄāĻি āϤোāĻŽাāϰ āĻāĻŽ্āĻĒিāĻāĻাāϰেāϰ D āĻĄ্āϰাāĻāĻেāϰ āĻেāϤāϰে 'programming' āύাāĻŽে āĻāĻāĻি āύāϤুāύ āĻĢোāϞ্āĻĄাāϰ āϤৈāϰি āĻāϰāĻŦে।
ā§Ē) os.error() -
āĻāĻি āĻ āĻĒাāϰেāĻিং āϏিāϏ্āĻেāĻŽ āϞেāĻেāϞেāϰ āĻুāϞ āĻŦা āĻāϰāϰāĻুāϞোāĻে (errors) āύিāϰ্āĻĻেāĻļ āĻāϰে। āϝāĻĻি āĻোāύো āĻĢাāĻāϞেāϰ āύাāĻŽ āĻŦা āĻĢোāϞ্āĻĄাāϰেāϰ āĻ িāĻাāύা āĻুāϞ āĻšā§, āĻিংāĻŦা āϏেāĻি āĻুঁāĻে āĻĒাāĻā§া āύা āϝাā§, āĻ āĻĨāĻŦা āĻāĻŽāύ āĻোāύো āϤāĻĨ্āϝ āĻĻেāĻā§া āĻšā§ āϝা āĻĄাāĻা āĻাāĻāĻĒ āĻšিāϏেāĻŦে āĻ িāĻ āĻিāύ্āϤু āĻ āĻĒাāϰেāĻিং āϏিāϏ্āĻেāĻŽ āϤা āĻ্āϰāĻšāĻŖ āĻāϰāϤে āĻĒাāϰāĻে āύা— āϤāĻāύ āĻāĻ āĻŽāĻĄিāĻāϞেāϰ āϏāĻŦ āĻĢাংāĻļāύ āĻāĻāĻি OSError āĻĻেāĻাā§ (raise āĻāϰে)।
ā§Ģ) os.rename() -
āĻāĻ āĻĢাংāĻļāύāĻি āĻোāύো āĻĢাāĻāϞ āĻŦা āĻĄিāϰেāĻ্āĻāϰিāϰ (āĻĢোāϞ্āĻĄাāϰ) āύাāĻŽ āĻĒāϰিāĻŦāϰ্āϤāύ (rename) āĻāϰāϤে āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰা āĻšā§। āϤāĻŦে āĻĢাāĻāϞেāϰ āύাāĻŽ āϤāĻāύāĻ āĻĒāϰিāĻŦāϰ্āϤāύ āĻšāĻŦে, āϝāĻĻি āĻĢাāĻāϞāĻি āĻŦাāϏ্āϤāĻŦে āĻāĻŽ্āĻĒিāĻāĻাāϰে āĻĨাāĻে (exists) āĻāĻŦং āĻŦ্āϝāĻŦāĻšাāϰāĻাāϰীāϰ āĻাāĻে āϏেāĻ āĻĢাāĻāϞāĻি āĻĒāϰিāĻŦāϰ্āϤāύ āĻāϰাāϰ āĻŽāϤো āĻĒ্āϰā§োāĻāύীā§ āĻĒাāϰāĻŽিāĻļāύ āĻŦা āĻ āϧিāĻাāϰ (privilege permission) āĻĨাāĻে।
āĻāĻি āĻĻুāĻি āĻāϰ্āĻুāĻŽেāύ্āĻ āĻ্āϰāĻšāĻŖ āĻāϰে:
- āĻĢাāĻāϞেāϰ āĻŦāϰ্āϤāĻŽাāύ āύাāĻŽ (current name)
- āĻĢাāĻāϞāĻিāϰ āύāϤুāύ āϝে āύাāĻŽ āϤুāĻŽি āĻĻিāϤে āĻাāĻ (new name)
import os
os.rename('data.txt', 'python.txt')
# āĻāĻ āĻোāĻĄāĻি āϤোāĻŽাāϰ āĻāĻŽ্āĻĒিāĻāĻাāϰে āĻĨাāĻা 'data.txt' āĻĢাāĻāϞāĻিāϰ āύাāĻŽ āĻĒāϰিāĻŦāϰ্āϤāύ āĻāϰে 'python.txt' āĻāϰে āĻĻেāĻŦে।
Third-party Modules
āϏাāϧাāϰāĻŖāϤ āϝāĻāύ āϤুāĻŽি āĻāĻāĻি āύāϤুāύ āĻĢোāύ āĻেāύো, āϤāĻāύ āϏেāĻি āϏāĻŽ্āĻāĻŦāϤ āĻিāĻু āĻŦিāϞ্āĻ-āĻāύ (āĻĢোāύে āĻāĻে āĻĨেāĻেāĻ āĻĻেāĻā§া) āĻŽোāĻŦাāĻāϞ āĻ ্āϝাāĻĒ্āϞিāĻেāĻļāύ āĻŦা āĻ ্āϝাāĻĒāϏāĻš āĻāϏে। āĻāĻ āĻŽোāĻŦাāĻāϞ āĻ ্āϝাāĻĒ্āϞিāĻেāĻļāύāĻুāϞো āĻāĻāĻĻāĻŽ āĻļুāϰু āĻĨেāĻেāĻ āϤোāĻŽাāϰ āĻŽোāĻŦাāĻāϞে āĻĒাāĻā§া āϝাā§ āĻāĻŦং āĻāĻুāϞো āĻিāύ্āϤু āϤুāĻŽি āύিāĻে āĻĢোāύে āĻāύāϏ্āĻāϞ āĻŦা āϝোāĻ āĻāϰোāύি (āϝেāĻŽāύ: āĻĢোāύেāϰ āύিāĻāϏ্āĻŦ āĻ্āϝাāϞāĻুāϞেāĻāϰ āĻŦা āĻā§ি āĻ ্āϝাāĻĒ)।
āĻিāύ্āϤু āĻāĻŽāύ āĻিāĻু āĻĒāϰিāϏ্āĻĨিāϤি āĻāϏে, āϝāĻāύ āĻ āϤিāϰিāĻ্āϤ āĻিāĻু āϏুāĻŦিāϧা āĻŦা āĻĢিāĻাāϰেāϰ āĻāύ্āϝ āϤোāĻŽাāĻে āĻŦাāĻāϰে āĻĨেāĻে āĻিāĻু āĻĨাāϰ্āĻĄ-āĻĒাāϰ্āĻি (third party) āĻŽোāĻŦাāĻāϞ āĻ ্āϝাāĻĒ āĻāύāϏ্āĻāϞ āĻāϰāϤে āĻšā§। āĻāĻ āĻ ্āϝাāĻĒāĻুāϞো āĻŦিāĻিāύ্āύ āϏ্āĻŦাāϧীāύ āĻĄেāĻেāϞāĻĒাāϰ āĻŦা āĻĒ্āϰোāĻ্āϰাāĻŽাāϰāϰা āϤৈāϰি āĻāϰেāύ āĻāĻŦং āĻāĻুāϞো āĻĒ্āϞে-āϏ্āĻোāϰ (Play Store) āĻিংāĻŦা āĻ ্āϝাāĻĒ āϏ্āĻোāϰ (App Store)-āĻāϰ āĻŽāϤো āĻাā§āĻাā§ āĻāĻĒāϞোāĻĄ āĻŦা āĻšোāϏ্āĻ āĻāϰা āĻĨাāĻে (āϝেāĻŽāύ: āĻĢেāϏāĻŦুāĻ, āĻšোā§াāĻāϏāĻ ্āϝাāĻĒ āĻŦা āĻŦিāĻিāύ্āύ āĻেāĻŽ)।
āĻāĻāĻāĻাāĻŦে, āĻĒাāĻāĻĨāύেāĻ āĻāĻŽāύ āĻিāĻু āĻŽāĻĄিāĻāϞ āϰā§েāĻে āϝা āĻĒৃāĻĨিāĻŦীāϰ āĻŦিāĻিāύ্āύ āĻĒ্āϰাāύ্āϤেāϰ āϏ্āĻŦাāϧীāύ āĻĄেāĻেāϞāĻĒাāϰāϰা āĻŦা āĻĒ্āϰোāĻ্āϰাāĻŽাāϰāϰা āϤৈāϰি āĻāϰেāĻেāύ। āϤুāĻŽি āϤোāĻŽাāϰ āĻĒ্āϰā§োāĻāύ āĻ āύুāϝাā§ী āĻāĻ āĻŽāĻĄিāĻāϞāĻুāϞো āϤোāĻŽাāϰ āĻĒ্āϰāĻেāĻ্āĻে āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϤে āĻĒাāϰো। āĻāĻ āϧāϰāύেāϰ āĻŽāĻĄিāĻāϞāĻুāϞোāĻে āĻĨাāϰ্āĻĄ-āĻĒাāϰ্āĻি āĻŽāĻĄিāĻāϞ (third-party modules) āĻŦāϞা āĻšā§।
āϤাāĻ, āĻŦিāϞ্āĻ-āĻāύ (āĻĒাāĻāĻĨāύেāϰ āϏাāĻĨে āĻāĻে āĻĨেāĻে āĻĨাāĻা) āĻŽāĻĄিāĻāϞ āĻāĻŦং āĻĨাāϰ্āĻĄ-āĻĒাāϰ্āĻি āĻŽāĻĄিāĻāϞেāϰ āĻŽāϧ্āϝে āĻāĻāĻŽাāϤ্āϰ āĻŦā§ āĻĒাāϰ্āĻĨāĻ্āϝ āĻšāϞো— āĻāĻŽাāĻĻেāϰ āĻŽোāĻŦাāĻāϞে āĻোāύো āĻĨাāϰ্āĻĄ-āĻĒাāϰ্āĻি āĻ ্āϝাāĻĒ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰাāϰ āĻāĻে āϝেāĻŽāύ āϤা āĻĄাāĻāύāϞোāĻĄ āĻŦা āĻāύāϏ্āĻāϞ āĻāϰāϤে āĻšā§, āĻ িāĻ āϤেāĻŽāύি āĻāĻ āĻŽāĻĄিāĻāϞāĻুāϞোāĻ āĻŦাāϏ্āϤāĻŦে āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰাāϰ āĻāĻে āĻāĻŽাāĻĻেāϰ āĻāĻŽ্āĻĒিāĻāĻাāϰে āĻĒ্āϰāĻĨāĻŽে āĻāύāϏ্āĻāϞ āĻāϰে āύিāϤে āĻšāĻŦে।
āϏāĻšāĻ āĻāĻĨাā§ āĻŦāϞāϤে āĻেāϞে, āĻĨাāϰ্āĻĄ-āĻĒাāϰ্āĻি āĻŽāĻĄিāĻāϞ āĻšāϞো āĻāĻŽāύ āϝেāĻোāύো āĻোāĻĄ āϝা āĻোāύো āϤৃāϤীā§ āĻĒāĻ্āώ āĻŦা āĻ āύ্āϝ āĻেāĻ āϞিāĻেāĻেāύ (āĻ āϰ্āĻĨাā§ āĻāĻি āϤুāĻŽিāĻ āϞেāĻোāύি, āĻāĻŦাāϰ āĻĒাāĻāĻĨāύ āϝাāϰা āϤৈāϰি āĻāϰেāĻে āϏেāĻ PSF āĻŦা Python Software Foundation-āĻ āϞেāĻেāύি)। āĻĒাāĻāĻĨāύেāϰ āύিāĻāϏ্āĻŦ āĻāĻāĻি āĻŦিāĻļাāϞ āϏ্āĻ্āϝাāύ্āĻĄাāϰ্āĻĄ āϞাāĻāĻŦ্āϰেāϰি (Standard Library) āϰā§েāĻে, āϝা āĻļুāϰু āĻĨেāĻেāĻ āĻ āύেāĻ āĻĻāϰāĻাāϰি āĻŽāĻĄিāĻāϞ āĻāĻŽাāĻĻেāϰ āĻĻিā§ে āĻĨাāĻে। āĻিāύ্āϤু āϤোāĻŽাāϰ āϝা āϝা āĻĒ্āϰā§োāĻāύ, āϤাāϰ āϏāĻŦāĻিāĻুāĻ āϝে āϏেāĻাāύে āĻĨাāĻāĻŦে āĻāĻŽāύāĻা āύā§। āĻāϰ āĻ িāĻ āĻāĻ āĻাā§āĻাāϤেāĻ āĻĒ্āϰā§োāĻāύ āĻšā§ āĻĨাāϰ্āĻĄ-āĻĒাāϰ্āĻি āĻŽāĻĄিāĻāϞেāϰ।
PyPI
āĻ িāĻ āϝেāϰāĻāĻŽ āĻāĻŽāϰা āĻāĻāĻি āĻĨাāϰ্āĻĄ āĻĒাāϰ্āĻি āĻ
্āϝাāĻĒ্āϞিāĻেāĻļāύ āĻ
্āϝাāĻĒ āϏ্āĻোāϰ āĻŦা āĻুāĻāϞ āĻĒ্āϞে āϏ্āĻোāϰ āĻĨেāĻে āĻāύ্āϏāĻāϞ āĻāϰāϤে āĻĒাāϰি, āϏেāϰāĻāĻŽ āĻাāĻŦে āĻĒাāĻāĻĨāύেāϰ āĻĨাāϰ্āĻĄāĻĒাāϰ্āĻি āĻŽāĻĄিāĻāϞ āĻুāϞো PyPI(Python Package Index) āĻ āĻāĻĒāϞোāĻĄ āĻāϰা āĻĨাāĻে। PyPI āĻšāϞো āĻĒাāĻāĻĨāύেāϰ āĻ
āĻĢিāϏিā§াāϞ āĻĨাāϰ্āĻĄ āĻĒাāϰ্āĻি āϏāĻĢāĻāĻāϝ়্āϝাāϰ Repository.
āĻĒিāĻāĻāĻĒি (PIP)
āϤাāĻ, āĻāĻŽāϰা āĻāĻŽাāĻĻেāϰ āĻĒ্āϰāϝ়োāĻāύীāϝ় āĻŽāĻĄিāĻāϞāĻুāϞো PyPI (Python Package Index) āĻĨেāĻে āĻāύāϏ্āĻāϞ āĻāϰāϤে āĻĒাāϰি। āĻāϰ āĻāĻ āĻাāĻāĻি āĻāϰাāϰ āĻāύ্āϝ āĻāĻŽāϰা PIP āύাāĻŽেāϰ āĻāĻāĻি āĻুāϞেāϰ āϏাāĻšাāϝ্āϝ āύিāĻ। āĻĒাāĻāĻĨāύেāϰ āϏাāĻĨে āĻāĻে āĻĨেāĻেāĻ āĻāĻāĻি āĻĒ্āϝাāĻেāĻ āĻŽ্āϝাāύেāĻাāϰ (package manager) āĻĻেāĻāϝ়া āĻĨাāĻে, āϝাāϰ āύাāĻŽ āĻšāϞো pip।
āĻāĻ āύাāĻŽāĻি āĻŽূāϞāϤ āĻāĻāĻি āϰিāĻাāϰ্āϏিāĻ āĻ ্āϝাāĻ্āϰোāύিāĻŽ (recursive acronym), āϝাāϰ āĻĒূāϰ্āĻŖ āϰূāĻĒ āĻšāϞো Pip Installs Packages। PyPI āĻĨেāĻে āĻীāĻাāĻŦে āϏ্āĻŦāϝ়ংāĻ্āϰিāϝ়āĻাāĻŦে āĻŽāĻĄিāĻāϞ āĻāύāϏ্āĻāϞ āĻāϰāϤে āĻšāϝ় āϤা Pip āύিāĻেāĻ āĻাāύে, āϤāĻŦে āϤোāĻŽাāϰ āĻĒ্āϰāϝ়োāĻāύ āĻšāϞে āϤুāĻŽি āύিāĻেāĻ āĻŽ্āϝাāύুāϝ়াāϞি PyPI-āϤে āĻিāϝ়ে āϏাāϰ্āĻ āĻāϰāϤে āĻĒাāϰো āĻŦা āĻুāϰে āĻĻেāĻāϤে āĻĒাāϰো।
āĻাāϰ্āĻŽিāύাāϞে (terminal) āύিāĻেāϰ āĻāĻŽাāύ্āĻĄāĻি āϰাāύ āĻāϰে āĻāĻŽāϰা PIP-āĻāϰ āϏাāĻšাāϝ্āϝে āϝেāĻোāύো āĻĒ্āϰāϝ়োāĻāύীāϝ় āĻŽāĻĄিāĻāϞ āĻāύāϏ্āĻāϞ āĻāϰāϤে āĻĒাāϰি:
pip install module_nameāĻāĻāĻŦাāϰ āĻŽāĻĄিāĻāϞāĻি āĻāύāϏ্āĻāϞ āĻšāϝ়ে āĻেāϞে, āĻŦিāϞ্āĻ-āĻāύ āĻŽāĻĄিāĻāϞāĻুāϞোāϰ āĻŽāϤোāĻ āĻāĻŽāϰা āϏāĻšāĻāĻাāĻŦে import āϏ্āĻেāĻāĻŽেāύ্āĻ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰে āϏেāĻিāĻে āĻāĻŽাāĻĻেāϰ āĻোāĻĄে āύিāϝ়ে āĻāϏāϤে (import āĻāϰāϤে) āĻāĻŦং āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϤে āĻĒাāϰি।
Custom Modules
āĻāĻŦ্āĻĻুāϞ্āϞাāĻš āϤাāϰ āĻŽোāĻŦাāĻāϞে āĻāĻŽāύ āĻāĻāĻি āĻ
্āϝাāĻĒ্āϞিāĻেāĻļāύ āĻেā§েāĻিāϞ āϝা āϤাāĻে āϤাāϰ āĻšোā§াāĻāϏāĻ
্āϝাāĻĒ (WhatsApp) āĻĨেāĻে āĻ
āύ্āϝ āĻŽাāύুāώেāϰ āϏ্āĻ্āϝাāĻাāϏ āĻŦা āϏ্āĻোāϰিāĻুāϞো āĻĄাāĻāύāϞোāĻĄ āĻāϰāϤে āϏাāĻšাāϝ্āϝ āĻāϰāĻŦে। āĻিāύ্āϤু āĻĻুঃāĻেāϰ āĻŦিāώ⧠āĻšāϞো, āϤāĻāύ āϤাāϰ āĻŽোāĻŦাāĻāϞে āĻāĻŽāύ āĻোāύো āĻŦিāϞ্āĻ-āĻāύ āĻ
্āϝাāĻĒ āĻিāϞ āύা, āĻāĻŦাāϰ āĻĒ্āϞে-āϏ্āĻোāϰ (PlayStore) āĻŦা āĻ
্āϝাāĻĒ āϏ্āĻোāϰেāĻ (App Store) āĻāĻ āϧāϰāύেāϰ āĻোāύো āĻ
্āϝাāĻĒ āĻĒাāĻā§া āϝাāĻ্āĻিāϞ āύা।
āĻিāύ্āϤু āĻāĻŦ্āĻĻুāϞ্āϞাāĻš āĻŽোāĻেāĻ āĻšাāϞ āĻেā§ে āĻĻেā§āύি! āϏে āϤাāϰ āύিāĻেāϰ āĻĒ্āϰā§োāĻāύ āĻ
āύুāϝাā§ী āύিāĻেāĻ āĻāĻāĻি āύāϤুāύ āĻŽোāĻŦাāĻāϞ āĻ
্āϝাāĻĒ āϤৈāϰি āĻāϰে āĻĢেāϞāϞ, āϝা āϏে āϝেāĻোāύো āϏāĻŽā§ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϤে āĻĒাāϰে। āĻ িāĻ āϤাāϰ āύিāĻেāϰ āϤৈāϰি āĻāĻāĻি āĻাāϏ্āĻāĻŽ āĻ
্āϝাāĻĒেāϰ āĻŽāϤো!
āĻāĻāĻāĻাāĻŦে, āĻĒাāĻāĻĨāύে āĻāĻŽāϰা āĻāĻŽাāĻĻেāϰ āĻĒ্āϰā§োāĻāύ āĻ āύুāϝাā§ী āύিāĻāϏ্āĻŦ āĻŽāĻĄিāĻāϞ āϤৈāϰি āĻāϰāϤে āĻĒাāϰি। āĻāĻ āϧāϰāύেāϰ āĻŽāĻĄিāĻāϞāĻুāϞোāĻে āĻাāϏ্āĻāĻŽ āĻŽāĻĄিāĻāϞ āĻŦāϞা āĻšā§। āĻ āϤāĻāĻŦ, āĻাāϏ্āĻāĻŽ āĻŽāĻĄিāĻāϞ āĻāϰ āĻিāĻুāĻ āύ⧗ āĻāĻি āĻšāϞো āĻĄেāĻেāϞāĻĒাāϰ āĻŦা āĻĒ্āϰোāĻ্āϰাāĻŽাāϰ āύিāĻে āϝে āĻŽāĻĄিāĻāϞāĻি āϤৈāϰি āĻāϰেāĻেāύ āϏেāĻি।
āĻĒাāĻāĻĨāύেāϰ āĻাāϏ্āĻāĻŽ āĻŽāĻĄিāĻāϞāĻুāϞো āĻ āύ্āϝ āϝেāĻোāύো āĻŽāĻĄিāĻāϞেāϰ āĻŽāϤোāĻ āĻাāĻ āĻāϰে āĻāĻŦং āĻāĻুāϞো āĻŽূāϞāϤ āϏাāϧাāϰāĻŖ āĻিāĻু āĻĒাāĻāĻĨāύ āĻĢাāĻāϞ (āϝেāĻŽāύ: .py āĻĢাāĻāϞ), āϝা āĻ āύ্āϝ āϝেāĻোāύো āĻĒাāĻāĻĨāύ āĻĢাāĻāϞে āĻāĻŽ্āĻĒোāϰ্āĻ (import) āĻāϰা āϝাā§। āϏāĻšāĻ āĻāĻĨাā§, āĻāĻি āĻšāϞো āĻāĻŽāύ āĻāĻāĻি āĻĢাāĻāϞ āϝাāϰ āĻŽāϧ্āϝে āĻŦেāĻļ āĻিāĻু āĻĢাংāĻļāύেāϰ āϏāĻŽāώ্āĻি āĻĨাāĻে, āϝা āϤুāĻŽি āϤোāĻŽাāϰ āĻŽূāϞ āĻĒ্āϰোāĻ্āϰাāĻŽে āϝুāĻ্āϤ āĻāϰāϤে āĻাāĻ।
āĻāϞো āĻāĻŦাāϰ āĻাāϏ্āĻāĻŽ āĻŽāĻĄিāĻāϞ āϤৈāϰি āĻāϰাāϰ āĻāĻŽā§āĻাāϰ āϏুāĻŦিāϧাāĻুāϞো āύিā§ে āĻāϞোāĻāύা āĻāϰা āϝাāĻ:
ā§§) āϝāĻĻি āĻāĻāĻি āĻĒ্āϰোāĻ্āϰাāĻŽে āĻĒ্āϰāĻুāϰ āĻĒāϰিāĻŽাāĻŖে āĻĢাংāĻļāύ āĻāĻŦং āĻ্āϞাāϏ (classes) āĻĨাāĻে, āϤāĻŦে āϏেāĻুāϞোāĻে āĻāϞাāĻĻা āĻāϞাāĻĻা āĻŽāĻĄিāĻāϞে āϝৌāĻ্āϤিāĻāĻাāĻŦে āĻুāĻিā§ে (organize) āϰাāĻা āϝাā§। āĻāĻāĻি āύিāϰ্āĻĻিāώ্āĻ āĻŽāĻĄিāĻāϞে āϏāĻŽāĻাāϤীāϝ় āĻŦা āĻāĻāĻ āĻāĻĻ্āĻĻেāĻļ্āϝে āϤৈāϰি āĻāϰা āĻ্āϞাāϏ, āĻĢাংāĻļāύ āĻāĻŦং āĻ āύ্āϝাāύ্āϝ āϰিāϏোāϰ্āϏāĻুāϞো āĻāĻŽা āϰাāĻা āĻšā§।
āĻোāĻĄেāϰ āĻāĻ āϧāϰāύেāϰ āĻোāĻাāύো āϰূāĻĒāĻে āĻŽāĻĄুāϞাāϰ āĻĄিāĻাāĻāύ (modular design) āĻŦāϞা āĻšāϝ়, āϝা āĻŦোāĻা, āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰা āĻāĻŦং āĻĒāϰāĻŦāϰ্āϤীāϤে āϰāĻ্āώāĻŖাāĻŦেāĻ্āώāĻŖ (maintain) āĻāϰা āĻ āύেāĻ āϏāĻšāĻ।
⧍) āĻāĻ āϧāϰāύেāϰ āĻŽāĻĄিāĻāϞ āύিā§ে āĻাāĻ āĻāϰāϞে āĻোāĻĄāĻে āĻĒুāύāϰ্āĻŦ্āϝāĻŦāĻšাāϰāϝোāĻ্āϝ (reusable) āĻāϰা āϝাā§। āϧāϰা āϝাāĻ, āϤোāĻŽাāϰ āĻĒ্āϰāĻেāĻ্āĻেāϰ āĻŦেāĻļ āĻā§েāĻāĻি āĻāϞাāĻĻা āĻĢাāĻāϞে āĻāĻāĻ āĻĢিāĻাāϰ āĻŦা āϞāĻিāĻ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϤে āĻšāĻŦে; āĻāĻŽāύ āĻĒāϰিāϏ্āĻĨিāϤিāϤে āĻŦাāϰāĻŦাāϰ āĻāĻāĻ āĻোāĻĄ āύা āϞিāĻে, āϤুāĻŽি āĻুāĻŦ āϏāĻšāĻেāĻ āϏেāĻ āϞāĻিāĻ āĻĻিā§ে āĻāĻāĻি āĻŽāĻĄিāĻāϞ āϤৈāϰি āĻāϰে āύিāϤে āĻĒাāϰো āĻāĻŦং āĻĒ্āϰā§োāĻāύāĻŽāϤো āϏāĻŦ āĻĢাāĻāϞে āϤা āĻāĻŽ্āĻĒোāϰ্āĻ (import) āĻāϰে āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϤে āĻĒাāϰো।
How it works
āĻāĻŽāϰা āĻāĻāύ āĻাāύি āĻাāϏ্āĻāĻŽ āĻŽāĻĄিāĻāϞ āĻী, āĻিāύ্āϤু āĻāĻি āĻীāĻাāĻŦে āĻাāĻ āĻāϰে? āĻāĻি āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰা āĻুāĻŦāĻ āϏāĻšāĻ, āύিāĻে āĻāϰ āϧাāĻĒāĻুāϞো āĻĻেāĻā§া āĻšāϞো:
- āϧাāĻĒ ā§§ (Step 1) - āĻĒ্āϰāĻĨāĻŽে āĻāĻāĻি āĻĢাāĻāϞ āϤৈāϰি āĻāϰো, āϧāϰা āϝাāĻ āĻĢাāĻāϞāĻিāϰ āύাāĻŽ logic.py। āĻāĻ āĻĢাāĻāϞেāϰ āĻেāϤāϰেāĻ āĻŽāĻĄিāĻāϞেāϰ āĻŽূāϞ āϞāĻিāĻ āĻŦা āĻĢাংāĻļāύāĻুāϞো āĻĨাāĻāĻŦে, āϝা āϤুāĻŽি āĻ āύ্āϝ āĻোāύো āĻĢাāĻāϞে āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϤে āĻাāĻ।
- āϧাāĻĒ ā§¨ (Step 2) - āĻāĻŦাāϰ āĻāϰেāĻāĻি āύāϤুāύ āĻĢাāĻāϞ āϤৈāϰি āĻāϰো, āϧāϰা āϝাāĻ āϏেāĻিāϰ āύাāĻŽ test.py। āĻāϰāĻĒāϰ import āϏ্āĻেāĻāĻŽেāύ্āĻ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰে āύিāĻে āĻĻেāĻাāύো āĻāĻĒাā§ে āϏেāĻ logic.py āĻĢাāĻāϞāĻিāĻে (āϝা āĻāĻāύ āĻāĻāĻি āĻŽāĻĄিāĻāϞ) āĻāĻ āύāϤুāύ āĻĢাāĻāϞে āĻāĻŽ্āĻĒোāϰ্āĻ āĻāϰো:
import logicāĻāĻāύ, āϤুāĻŽি āĻĒাāĻāĻĨāύেāϰ āĻ āύ্āϝ āϝেāĻোāύো āϏাāϧাāϰāĻŖ āĻŽāĻĄিāĻāϞেāϰ āĻŽāϤোāĻ āĻāĻ logic āĻŽāĻĄিāĻāϞāĻি āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϤে āĻĒাāϰāĻŦে āĻāĻŦং āĻāϰ āĻেāϤāϰে āĻĨাāĻা āϏāĻŦ āĻĢিāĻাāϰ āĻŦা āĻĢাংāĻļāύāĻুāϞো āĻ ্āϝাāĻ্āϏেāϏ āĻāϰāϤে āĻĒাāϰāĻŦে।
āĻাāϏ্āĻāĻŽ āĻŽāĻĄিāĻāϞ āϤৈāϰি āĻāϰা (Creating Custom Module)
āĻাāϏ্āĻāĻŽ āĻŽāĻĄিāĻāϞ āĻāϰ āĻিāĻু āύ⧗ āĻāĻি āĻšāϞো āĻĄেāĻেāϞāĻĒাāϰ āĻŦা āĻĒ্āϰোāĻ্āϰাāĻŽাāϰ āύিāĻে āϝে āĻŽāĻĄিāĻāϞāĻি āϤৈāϰি āĻāϰেāύ āϏেāĻি। āĻāĻি āĻ āύ্āϝ āϝেāĻোāύো āĻŽāĻĄিāĻāϞেāϰ āĻŽāϤোāĻ āĻāĻŦং āĻāĻুāϞো āĻŽূāϞāϤ āϏাāϧাāϰāĻŖ āĻিāĻু āĻĒাāĻāĻĨāύ āĻĢাāĻāϞ āϝা āĻ āύ্āϝ āĻĢাāĻāϞে āĻāĻŽ্āĻĒোāϰ্āĻ (import) āĻāϰা āϝাā§। āϤো āĻāϞো, āĻāĻ āϏেāĻāĻļāύে āĻāĻŽāϰা āĻāĻŽাāĻĻেāϰ āύিāĻāϏ্āĻŦ āĻāĻāĻি āĻাāϏ্āĻāĻŽ āĻŽāĻĄিāĻāϞ āϤৈāϰি āĻāϰি।
āϧāϰা āϝাāĻ, āϤোāĻŽাāϰ āĻāĻŽāύ āĻāĻāĻি āĻ ্āϝাāĻĒ্āϞিāĻেāĻļāύ āĻāĻে āϝেāĻাāύে āĻāĻāĻি āϏংāĻ্āϝা āĻোā§ (even) āύাāĻি āĻŦিāĻোā§ (odd)— āϤা āĻŦাāϰāĻŦাāϰ āĻĒāϰীāĻ্āώা āĻāϰা āĻĒ্āϰā§োāĻāύ। āĻāĻি āĻļুāϧু āĻāĻāĻি āĻĢাāĻāϞে āύā§, āĻŦāϰং āĻāĻāĻি āĻĒ্āϰāĻেāĻ্āĻেāϰ āĻ āύেāĻāĻুāϞো āĻāϞাāĻĻা āĻĢাāĻāϞে āĻĒāϰীāĻ্āώা āĻāϰāϤে āĻšāϤে āĻĒাāϰে। āĻāĻ āϧāϰāύেāϰ āĻĒāϰিāϏ্āĻĨিāϤিāϤে, āĻāĻŽāϰা āĻāĻāĻি āĻাāϏ্āĻāĻŽ āĻŽāĻĄিāĻāϞ āϤৈāϰি āĻāϰāϤে āĻĒাāϰি āϝাāϰ āĻŽāϧ্āϝে āϏংāĻ্āϝাāĻি āĻĒāϰীāĻ্āώা āĻāϰাāϰ āĻĻাā§িāϤ্āĻŦ āύেāĻā§াāϰ āĻāύ্āϝ āĻāĻāĻি āύিāϰ্āĻĻিāώ্āĻ āĻĢাংāĻļāύ āĻĨাāĻāĻŦে।
āϤুāĻŽি āĻুāĻŦ āϏāĻšāĻেāĻ āϏেāĻ āĻĢাāĻāϞ āĻŦা āĻŽāĻĄিāĻāϞāĻি āĻāĻŽ্āĻĒোāϰ্āĻ āĻāϰāϤে āĻĒাāϰো āĻāĻŦং āĻĒ্āϰā§োāĻāύীā§ āĻĢাংāĻļāύāĻিāĻে āĻāϞ (call) āĻāϰāϤে āĻĒাāϰো। āϤাāĻšāϞে āĻāϞো, āϏাāĻŽāύে āĻāĻিā§ে āϝাāĻā§া āϝাāĻ āĻāĻŦং āĻāĻ āĻাāĻāĻি āĻĒ্āϰ্āϝাāĻ্āĻিāĻ্āϝাāϞি āĻāϰা āĻļুāϰু āĻāϰি!
āĻāϞো āĻāĻāĻি āĻĒাāĻāĻĨāύ āĻĢাāĻāϞ āϤৈāϰি āĻāϰি āĻāĻŦং āϏেāĻিāϰ āύাāĻŽ āĻĻিāĻ oddeven.py। āĻāĻ āĻĢাāĻāϞেāϰ āĻেāϤāϰে āĻāĻŽাāĻĻেāϰ āĻĻুāĻি āĻŽেāĻĨāĻĄ āĻŦা āĻĢাংāĻļāύ āĻĨাāĻāĻŦে: isEven() āĻāĻŦং isOdd()। āϏংāĻ্āϝাāĻিāϰ āĻāĻĒāϰ āĻিāϤ্āϤি āĻāϰে āĻāĻ āĻĢাংāĻļāύāĻুāϞো True (āϏāϤ্āϝ) āĻ
āĻĨāĻŦা False (āĻŽিāĻĨ্āϝা) āϰিāĻাāϰ্āύ āĻāϰāĻŦে। āύিāĻে āĻāĻŽাāĻĻেāϰ oddeven.py āĻĢাāĻāϞেāϰ āĻোāĻĄāĻি āĻĻেāĻā§া āĻšāϞো:
# āĻāĻি āĻোā§ āϏংāĻ্āϝা āĻĒāϰীāĻ্āώা āĻāϰাāϰ āĻĢাংāĻļāύ
def isEven(number):
if number % 2 == 0: # āϏংāĻ্āϝাāĻিāĻে ⧍ āĻĻিā§ে āĻাāĻ āĻāϰāϞে āϝāĻĻি āĻাāĻāĻļেāώ ā§Ļ āĻšā§
return True # āϤাāĻšāϞে āĻāĻি āĻোā§ āϏংāĻ্āϝা (True)
else:
return False # āĻ
āύ্āϝāĻĨাā§ āĻāĻি āĻোā§ āϏংāĻ্āϝা āύ⧠(False)
# āĻāĻি āĻŦিāĻোā§ āϏংāĻ্āϝা āĻĒāϰীāĻ্āώা āĻāϰাāϰ āĻĢাংāĻļāύ
def isOdd(number):
if number % 2 != 0: # āϏংāĻ্āϝাāĻিāĻে ⧍ āĻĻিā§ে āĻাāĻ āĻāϰāϞে āϝāĻĻি āĻাāĻāĻļেāώ ā§Ļ āύা āĻšā§
return True # āϤাāĻšāϞে āĻāĻি āĻŦিāĻোā§ āϏংāĻ্āϝা (True)
else:
return False # āĻ
āύ্āϝāĻĨাā§ āĻāĻি āĻŦিāĻোā§ āϏংāĻ্āϝা āύ⧠(False)
āĻāĻāύ, āĻāϞো āĻāĻāĻি āύāϤুāύ āĻĢাāĻāϞ āϤৈāϰি āĻāϰি āϝাāϰ āύাāĻŽ āĻĻিāĻ project.py। āĻāĻ āĻĢাāĻāϞāĻিāϤে āĻāĻŽাāĻĻেāϰ āϏেāĻ āĻĢিāĻাāϰেāϰ āĻĒ্āϰā§োāĻāύ āĻšāĻŦে āϝা āĻāĻŽāϰা āĻāĻāĻু āĻāĻে oddeven.py āĻĢাāĻāϞে āϤৈāϰি āĻāϰেāĻি। āϤাāĻ āĻāĻŽāϰা āĻুāĻŦ āϏāĻšāĻāĻাāĻŦে āĻĢাāĻāϞāĻিāĻে āĻāĻŽ্āĻĒোāϰ্āĻ āĻāϰāĻŦ āĻāĻŦং āĻāϰ āĻেāϤāϰেāϰ āĻĢাংāĻļāύāĻুāϞো āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāĻŦ। āĻāϞো āĻাāĻāĻা āĻļুāϰু āĻāϰি āĻāĻŦং āĻāĻŽাāĻĻেāϰ āϤৈāϰি āĻāϰা āĻাāϏ্āĻāĻŽ āĻŽāĻĄিāĻāϞāĻি āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰি:
import oddeven # āĻāĻŽাāĻĻেāϰ āϤৈāϰি āĻāϰা āĻাāϏ্āĻāĻŽ āĻŽāĻĄিāĻāϞāĻি āĻāĻŽ্āĻĒোāϰ্āĻ āĻāϰা āĻšāϞো
# āĻŦ্āϝāĻŦāĻšাāϰāĻাāϰীāϰ āĻাāĻ āĻĨেāĻে āĻāύāĻĒুāĻ āύিā§ে āϏেāĻিāĻে āĻĒূāϰ্āĻŖāϏংāĻ্āϝাā§ (integer) āϰূāĻĒাāύ্āϤāϰ āĻāϰা āĻšāĻ্āĻে
number = int(input("Enter a number to test: "))
print(oddeven.isEven(number)) # āϏংāĻ্āϝাāĻি āĻোā§ āĻি āύা āĻĒāϰীāĻ্āώা āĻāϰে āϰেāĻাāϞ্āĻ āĻĒ্āϰিāύ্āĻ āĻāϰāĻŦে
print(oddeven.isOdd(number)) # āϏংāĻ্āϝাāĻি āĻŦিāĻোā§ āĻি āύা āĻĒāϰীāĻ্āώা āĻāϰে āϰেāĻাāϞ্āĻ āĻĒ্āϰিāύ্āĻ āĻāϰāĻŦে
āĻāĻি āϰাāύ āĻāϰāϞে āύিāĻেāϰ āĻŽāϤো āĻāĻāĻāĻĒুāĻ āϤৈāϰি āĻšāĻŦে:
Enter a number to test: 4
True
False
