පටුන[සඟවන්න][පෙන්වන්න]
මෙම දේශනය Python හි ඇති මොඩියුල සහ පැකේජ වටා විහිදේ.
ඒවා ඔබේ කේතය ගොනු ආකාරයෙන් සංවිධානය කිරීමට ක්රමයක් වන අතර ඔබ Python සමඟ වෙබ් යෙදුම් තැනීමට අදහස් කරන්නේ නම් එය ඉතා වැදගත් වේ.
මොඩියුල
Python හි මොඩියුලයක් මූලික වශයෙන් අපගේ කේතය ගොනු ලෙස සංවිධානය කිරීමට භාවිතා කරන python කේතයක් සහිත ගොනුවකි. එය සුපිරි වෙළඳසැලක කොටස් ලෙස සිතන්න. සුපර් මාර්කට් එකකට ගියාම පලතුරු, එළවලු, පිරිසුදු කිරීමේ නිෂ්පාදන ආදී විවිධ අංශ තියෙනවා.ඒ හැම භාණ්ඩයක්ම තියෙන එක කොටසක් පේන්නේ නැහැ.
ක්රමලේඛනයේ ද එයම සංකල්පයකි. main.py හි සියලුම ක්රියාකාරකම් සහ පන්ති සමඟ අපගේ සියලුම කේතය ලිවීම වෙනුවට, අපි අපගේ කේතය ගොනු කිහිපයකට බෙදන්නෙමු. සෑම ගොනුවක්ම මොඩියුලයක් ලෙස හැඳින්වේ. මේ සමඟ, අපගේ කේතය වඩා හොඳින් සංවිධානය වී ව්යුහගත වී ඇතිවා පමණක් නොව, අපගේ කේතය නැවත භාවිතා කිරීමටද අපට හැකියාව ඇත. අපි එය උදාහරණයක් හරහා බලමු.
බර රාත්තල් සිට කිලෝග්රෑම් දක්වා සහ අනෙක් අතට පරිවර්තනය කිරීම සඳහා කාර්යයන් දෙකක් නිර්වචනය කරමු.
def lbs_to_kg(weight):
return weight * 0.45
def kg_to_lbs(weight):
return weight / 0.45
දැන්, අපට මෙම ශ්රිත දෙක ගෙන ඒවා "පරිවර්තක" නමින් වෙනම මොඩියුලයකට දැමිය හැකිය, පසුව එය මෙම පරිවර්තක ක්රියාකාරකම් අවශ්ය ඕනෑම වැඩසටහනකට ආනයනය කළ හැකිය. මම මේක කරන හැටි කියලා දෙන්නම්.
අපි අපගේ ව්යාපෘති පැනලය විවෘත කර ව්යාපෘතිය මත දකුණු-ක්ලික් කර නව ගොනුවක් එක් කරමු. අපි මෙම ගොනුව "Converters.py" ලෙස හඳුන්වමු.
දැන් පෙරනිමි ගොනුවෙන් කේතය පිටපත් කර එය "Converters.py" වෙත අලවන්න.
මෙය සමඟ, අපි අපගේ ප්රධාන මොඩියුලය පිරිසිදු කර ඇති අතර එය විවිධ ක්රියාකාරකම් වලින් පිරී නැත. අපි පන්ති සමඟ තවත් කාර්යයන් ලියන විට, අපි ඒවා ඒවායේ අනුරූප මොඩියුලවල තබමු. මොඩියුලයක සියලුම අදාළ කාර්යයන් සහ පන්ති අඩංගු විය යුතුය. දැන්, අපට පරිවර්තක මොඩියුලය අපගේ යෙදුම් මොඩියුලයට ආයාත කිරීමට අවශ්යයි. මෙය සිදු කිරීම සඳහා, ලියන්න import converters
".py" දිගුව නොමැතිව ඉහළින්.
ක්රම වලට සමාන dot operator එකක් භාවිතා කිරීමෙන් අපට module එකක සාමාජිකයන්ට ප්රවේශ විය හැක.
අපි කිලෝග්රෑම් 70 පවුම් බවට පරිවර්තනය කරමු:
මොඩියුල ආනයනය කිරීම සඳහා තවත් වාක්ය ඛණ්ඩයක් ද ඇත. සම්පූර්ණ මොඩියුලයම ආනයනය කරනවා වෙනුවට, එම මොඩියුලයෙන් අපට නිශ්චිත කාර්යයන් ආනයනය කළ හැකිය. අපිට ටයිප් කරන්න පුළුවන් from Converters import
සහ පවතින ශ්රිත ලැයිස්තුව පෙන්වීමට “control + space ඔබන්න. මේ සමඟ, අපට මෙම කාර්යය කෙලින්ම හැඳින්විය හැක.
ව්යායාම
මෙන්න ඔබේ ව්යායාමය.
මෙය අප සාකච්ඡා කළ දේශනයේ අභ්යාසයකට සම්බන්ධයි.ලූප සඳහා” එහිදී අපි ලැයිස්තුවකින් විශාලතම අංකය සොයා ගැනීමට වැඩසටහනක් ලිව්වෙමු
numbers = [8, 3, 6, 10, 5]
max = numbers[0]
for number in numbers:
if number > max:
max = number
print(max)
මෙම කේතයට දැනට සංවිධානයක් නොමැත. අපට කිසිදු කාර්යයක් හෝ මොඩියුලයක් නොමැති අතර වැඩසටහන තනි ගොනුවක ලියා ඇත. කුඩා වැඩසටහන් සඳහා එය කමක් නැත, නමුත් ඔබේ වැඩසටහන් වර්ධනය වන විට, ඔබේ කේතය පන්ති සහ මොඩියුලවලට නිසි ලෙස සංවිධානය කළ යුතුය. එමනිසා, මෙම අභ්යාසයේ කොටසක් ලෙස, ඔබට ශ්රිතයක් ලිවීමට අවශ්යයි, එය අමතන්න find_max
. මෙම ශ්රිතය ලැයිස්තුවක් ගෙන එම ලැයිස්තුවේ ඇති විශාලතම අංකය ලබා දිය යුතුය. ඊට පස්සේ ගිහින් මේ function එක වෙනම module එකකට දාලා මෙතනින් extract කරලා module එකකට දාන්න. utils
. මෙම මොඩියුලයේ උපයෝගිතා කාර්යයන් සමූහයක් අඩංගු විය යුතුය. ආනයනය කරන්න utils
මොඩියුලය වත්මන් මොඩියුලයට ඇතුල් කර අමතන්න find_max
කාර්යය. අවසාන වශයෙන්, ප්රතිඵලය ලබාගෙන එය ටර්මිනලය මත මුද්රණය කරන්න.
මෙම ව්යායාමය තරමක් අභියෝගාත්මක නමුත් පහසුවෙන් කළ හැකි ව්යායාමයකි.
විසඳුමක්
කාර්යයක් අර්ථ දැක්වීමෙන් ආරම්භ කරන්න find_max
සහ අංක නමින් පරාමිතියක් එක් කරන්න. මෙම ශ්රිතය තුළ, ලැයිස්තුවක ඇති විශාලතම සංඛ්යාව සෙවීම සඳහා ඇල්ගොරිතම ලියන්න.
def find_max(numbers):
max = numbers[0]
for number in numbers:
if number > max:
max = number
return max
මෙම කේතය "utils.py" ගොනුවක මොඩියුලයක් ලෙස සුරකින්න.
අපගේ ප්රධාන වැඩසටහන වෙත ආපසු, සින්ටැක්ස් දෙකෙන් මොඩියුලය ආයාත කර සරලව තර්කනය ක්රියාත්මක කරන්න.
එක දෙයක්, මම ඔබේ අවධානය යොමු කළ යුත්තේ යටපත් වූ අයයි max
. ඒකට හේතුව තමයි max
යනු පයිතන් හි ගොඩනංවන ලද ශ්රිතයක් වන අතර අපි එය නැවත නිර්වචනය කරමින් සිටිමු. එබැවින් මෙය අනතුරු ඇඟවීමකි පයිතන් සම්පාදකය අපට තවදුරටත් එහි ගොඩනඟන කාර්යය ලෙස max භාවිතා කළ නොහැකි බව.
පයිතන් හි බිල්ට් මොඩියුල
ඊමේල් යැවීම, දිනය සහ වේලාව සමඟ වැඩ කිරීම, අහඹු අගයන් සහ මුරපද උත්පාදනය කිරීම වැනි පොදු කාර්යයන් සඳහා මොඩියුල කිහිපයක් අඩංගු සම්මත පුස්තකාලයක් සමඟ Python පැමිණේ. පයිතන් තුළ දැනටමත් බොහෝ මොඩියුලයන් ගොඩනගා ඇත, එයින් අදහස් කරන්නේ අපට නැවත භාවිතා කළ හැකි බොහෝ ක්රියාකාරීත්වය දැනටමත් ඇති බවයි. ඔබට මෙම මොඩියුල සොයාගත හැකිය මෙහි.
පැකේජ
පැකේජ මූලික වශයෙන් මොඩියුල මත අපගේ කේතය සංවිධානය කිරීමට තවත් ක්රමයකි. සැබෑ ව්යාපෘතියක මොඩියුල සිය ගණනක් හෝ දහස් ගණනක් අඩංගු විය හැකි අතර කාලයත් සමඟ අපගේ නාමාවලිය බොහෝ ලිපිගොනු වලින් පිරී යනු ඇත. එබැවින්, වඩා හොඳ ප්රවේශයක් වන්නේ පැකේජය බහු මොඩියුල සඳහා බහාලුමක් බවට පත් කරන පැකේජයක් තුළ අදාළ මොඩියුල සංවිධානය කිරීමයි.
ව්යාපෘතියට නව ඩිරෙක්ටරියක් එකතු කරන අතර අදාළ සියලුම මොඩියුල එම නාමාවලියට එකතු වේ. උදාහරණයක් ලෙස, සාප්පු සංකීර්ණයක් ගැන සිතන්න. සාප්පු සංකීර්ණයක පිරිමි, ගැහැණු සහ ළමා ඇඳුම් සඳහා විවිධ කොටස් පැකේජ වැනිය. සෑම අංශයකම සපත්තු, ටී-ෂර්ට් සහ ජැකට් වැනි විවිධ නිෂ්පාදන සඳහා විවිධ ප්රදේශ ඇත. මේවා මොඩියුල ලෙස සිතන්න.
අපි බලමු කොහොමද Python වල පැකේජ සාදා භාවිතා කරන්නේ කියලා.
පළමුව, ව්යාපෘති පැනලයෙන් නව නාමාවලියක් එක් කරන්න. අපි එය "eCommerce" ලෙස හඳුන්වමු. මෙම පැකේජයේ ඊ-වාණිජ්ය යෙදුමකට අදාළ සියලුම මොඩියුල අඩංගු වේ.
එය තවමත් හිස් නාමාවලියක් වන අතර එය පැකේජයක් බවට පරිවර්තනය කිරීම සඳහා, අපි එහි විශේෂ ගොනුවක් සෑදිය යුතුය. මෙම නාමාවලියෙහි නව python ගොනුවක් එක් කර එම ගොනුව "__init__" ලෙස නම් කරන්න. එය පයිතන් හි විශේෂ සම්මුතියක් වන අතර පයිතන් පරිවර්තකයා නාමාවලියක මෙම නම සහිත ගොනුවක් දුටු විට, එය මෙම නාමාවලිය පැකේජයක් ලෙස සලකයි.
පැකේජයක් නිර්මාණය කිරීම සඳහා විකල්ප සහ සංක්ෂිප්ත ක්රමයක් ද අප සතුව ඇත. ව්යාපෘති පැනලය මත දකුණු-ක්ලික් කර ලැයිස්තුවෙන් පයිතන් පැකේජයක් සාදන්න. එය "ඊ-වාණිජ්යය" ලෙස නම් කරන්න, එපමණයි. එය ස්වයංක්රීයව “__init__” නමින් පයිතන් ගොනුවක් සහිත නාමාවලියක් සාදනු ඇත.
දැන්, අපි පැකේජයේ මොඩියුලයක් සාදා එය "නැව්ගත කිරීම" ලෙස නම් කරමු. මෙම මොඩියුලය තුළ, නැව්ගත කිරීමේ පිරිවැය ගණනය කිරීම සඳහා සරල කාර්යයක් නිර්මාණය කරමු.
def calc_shipping():
print("calc_shipping")
අපගේ ප්රධාන මොඩියුලයේ මෙම කාර්යයට ප්රවේශ වීමට, අපට එය ඊ-වාණිජ්ය පැකේජය හරහා ප්රවේශ විය යුතුය. නැවත වරක් මෙම මොඩියුලය ආනයනය කිරීමට අපට ක්රම දෙකක් තිබේ.
පළමු ක්රමයේදී, අපට සම්පූර්ණ මොඩියුලයම ආයාත කළ හැකි අතර පසුව මෙවැනි ශ්රිතයක් ස්වාධීනව ඇමතීමට හැකිය:
import eCommerce.shipping
eCommerce.shipping.calc_shipping()
කෙසේ වෙතත්, මෙම ප්රවේශය සමඟ, මෙම මොඩියුලයට එක් කාර්යයක් ඇමතීමට එය උපසර්ග කිරීම අවශ්ය වේ eCommerce.shipping.
එය ඉතා වාචික ය. එබැවින්, පැකේජ සමඟ වැඩ කිරීමේදී අපි බොහෝ විට දෙවන ප්රවේශය භාවිතා කර භාවිතා කරමු from
ප්රකාශය.
from eCommerce.shipping import calc_shipping
calc_shipping()
ඔබට එක් මොඩියුලයක බහුවිධ කාර්යයන් තිබේ නම්, ඒවා අතර කොමා භාවිතා කිරීමෙන් ඔබට ඒවා සියල්ලම තනි පේළියකින් ආයාත කළ හැක. අපේ නැව්ගත කිරීමේ මොඩියුලයේ බදු ගණනය කිරීම සඳහා තවත් කාර්යයක් ඇතැයි සිතමු. එය මෙලෙස ආනයනය කරනු ලැබේ:
from eCommerce.shipping import calc_shipping, calc_tax
ඔබට තනි මොඩියුල ආයාත කළ හැකි අතර වැඩසටහනේ පසු අදියරකදී කැඳවීමට ශ්රිත අත්හැරිය හැක. අපි මොඩියුල නැව්ගත කිරීම ආයාත කර පසුව කාර්යය ඇමතීමට තිත් ක්රියාකරු භාවිතා කරමු calc_shipping.
from eCommerce import shipping
shipping.calc_shipping()
අවසන් කරන්න!
Python හි පැකේජ සහ මොඩියුල අතිශයින් වැදගත් වේ. විශේෂයෙන්ම, ඔබ ගොඩනැගීමට භාවිතා කරන Django වැනි රාමුවක් සමඟ වැඩ කිරීමට අවශ්ය විට වෙබ් යෙදුම් පයිතන් සමඟ. අපි තවත් පයිතන් පාඨමාලාවක් අතරතුර ජැන්ගෝ ගැන සොයා බලමු.
මෙය මෙම ලිපි මාලාවේ අවසන් සාම්ප්රදායික දේශනය විය. මීළඟ දේශනය අපගේ සුපුරුදු ආකෘතියෙන් බැහැර වන අතර අපි Python හි වැදගත් භාවිත අවස්ථා කිහිපයක් ඉගෙන ගනිමු. එය මෙම ලිපි මාලාවේ අවසානය සනිටුහන් කරන අතර අපි අපගේ මීළඟ Python මාලාව වෙත යමු. ඒ සඳහා රැඳී සිටින්න.
ඔබමයි