பொருளடக்கம்[மறை][காட்டு]
இந்த விரிவுரை பைத்தானில் உள்ள தொகுதிகள் மற்றும் தொகுப்புகளை சுற்றி விரியும்.
அவை உங்கள் குறியீட்டை கோப்புகளின் வடிவில் ஒழுங்கமைப்பதற்கான ஒரு வழியாகும், மேலும் நீங்கள் பைதான் மூலம் இணையப் பயன்பாடுகளை உருவாக்க விரும்பினால் மிகவும் முக்கியமானவை
தொகுதிகள்
பைத்தானில் உள்ள ஒரு தொகுதி என்பது அடிப்படையில் சில பைதான் குறியீட்டைக் கொண்ட ஒரு கோப்பாகும், இது நமது குறியீட்டை கோப்புகளாக ஒழுங்கமைக்கப் பயன்படுத்துகிறது. ஒரு பல்பொருள் அங்காடியில் உள்ள பிரிவுகளைப் போல நினைத்துப் பாருங்கள். நீங்கள் ஒரு பல்பொருள் அங்காடிக்குச் செல்லும்போது பழங்கள், காய்கறிகள், துப்புரவுப் பொருட்கள் போன்றவற்றுக்கு வெவ்வேறு பிரிவுகள் உள்ளன. எல்லாப் பொருட்களிலும் ஒரு பகுதியை நீங்கள் பார்க்க முடியாது.
நிரலாக்கத்திலும் இதே கருத்துதான். 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" நீட்டிப்பு இல்லாமல் மேலே.
முறைகளைப் போன்ற டாட் ஆபரேட்டரைப் பயன்படுத்தி ஒரு தொகுதியின் உறுப்பினர்களை நாம் அணுகலாம்.
70 கிலோவை பவுண்டுகளாக மாற்றுவோம்:
தொகுதிகளை இறக்குமதி செய்வதற்கு மற்றொரு தொடரியல் உள்ளது. முழு தொகுதியையும் இறக்குமதி செய்வதற்கு பதிலாக, அந்த தொகுதியிலிருந்து குறிப்பிட்ட செயல்பாடுகளை நாம் இறக்குமதி செய்யலாம். நாம் தட்டச்சு செய்யலாம் from Converters import
கிடைக்கக்கூடிய செயல்பாடுகளின் பட்டியலைக் காட்ட “கண்ட்ரோல் + ஸ்பேஸை அழுத்தவும். இதன் மூலம், இந்த செயல்பாட்டை நேரடியாக அழைக்கலாம்.
உடற்பயிற்சி
இதோ உங்கள் உடற்பயிற்சி.
இது நாங்கள் விவாதித்த விரிவுரையின் ஒரு பயிற்சியுடன் தொடர்புடையது "சுழல்களுக்கு” ஒரு பட்டியலிலிருந்து மிகப்பெரிய எண்ணைக் கண்டறிய ஒரு நிரலை எழுதினோம்
numbers = [8, 3, 6, 10, 5]
max = numbers[0]
for number in numbers:
if number > max:
max = number
print(max)
இந்தக் குறியீட்டில் தற்போது எந்த நிறுவனமும் இல்லை. எங்களிடம் செயல்பாடுகள் அல்லது தொகுதிகள் எதுவும் இல்லை மற்றும் நிரல் ஒரு கோப்பில் எழுதப்பட்டுள்ளது. சிறிய நிரல்களுக்கு இது பரவாயில்லை, ஆனால் உங்கள் திட்டங்கள் வளரும்போது, உங்கள் குறியீட்டை வகுப்புகள் மற்றும் தொகுதிகளாக ஒழுங்காக ஒழுங்கமைக்க வேண்டும். எனவே, இந்த பயிற்சியின் ஒரு பகுதியாக, நீங்கள் ஒரு செயல்பாட்டை எழுத விரும்புகிறேன், அதை அழைக்கவும் find_max
. இந்த செயல்பாடு ஒரு பட்டியலை எடுத்து, அந்த பட்டியலில் உள்ள மிகப்பெரிய எண்ணை வழங்க வேண்டும். அதன் பிறகு மேலே சென்று இந்த செயல்பாட்டை ஒரு தனி தொகுதியில் வைத்து, அதை இங்கிருந்து பிரித்தெடுத்து, அதை ஒரு தொகுதியில் வைக்கவும். 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
பைத்தானில் உள்ளமைக்கப்பட்ட செயல்பாடு மற்றும் நாங்கள் அதை மறுவரையறை செய்கிறோம். எனவே இது ஒரு எச்சரிக்கை பைதான் கம்பைலர் அதன் உள்ளமைக்கப்பட்ட செயல்பாடாக நாம் இனி அதிகபட்சத்தைப் பயன்படுத்த முடியாது.
பைத்தானில் உள்ளமைக்கப்பட்ட தொகுதிகள்
மின்னஞ்சல்களை அனுப்புதல், தேதி மற்றும் நேரத்துடன் பணிபுரிதல், சீரற்ற மதிப்புகள் மற்றும் கடவுச்சொற்களை உருவாக்குதல் போன்ற பொதுவான பணிகளுக்கான பல தொகுதிகளைக் கொண்ட நிலையான நூலகத்துடன் பைதான் வருகிறது. பைத்தானில் ஏற்கனவே பல தொகுதிகள் கட்டமைக்கப்பட்டுள்ளன, அதாவது நாம் மீண்டும் பயன்படுத்தக்கூடிய பல செயல்பாடுகள் ஏற்கனவே உள்ளன. இந்த தொகுதிகளை நீங்கள் காணலாம் இங்கே.
தொகுப்புகள்
தொகுப்புகள் அடிப்படையில் எங்கள் குறியீட்டை தொகுதிகளின் மேல் ஒழுங்கமைக்க மற்றொரு வழி. ஒரு உண்மையான திட்டமானது நூற்றுக்கணக்கான அல்லது ஆயிரக்கணக்கான தொகுதிக்கூறுகளைக் கொண்டிருக்கலாம், மேலும் காலப்போக்கில் எங்கள் கோப்பகம் பல கோப்புகளுடன் பெருகும். எனவே, ஒரு தொகுப்பின் உள்ளே தொடர்புடைய தொகுதிகளை ஒழுங்கமைப்பது ஒரு சிறந்த அணுகுமுறையாகும், இது தொகுப்பை பல தொகுதிகளுக்கான கொள்கலனாக மாற்றுகிறது.
திட்டத்தில் ஒரு புதிய கோப்பகம் சேர்க்கப்பட்டது மற்றும் தொடர்புடைய அனைத்து தொகுதிகளும் அந்த கோப்பகத்தில் சேர்க்கப்படும். உதாரணமாக, ஒரு வணிக வளாகத்தை நினைத்துப் பாருங்கள். ஒரு மாலில் ஆண்கள், பெண்கள் மற்றும் குழந்தைகளுக்கான ஆடைகள் பொதிகள் போன்ற பல்வேறு பிரிவுகள் உள்ளன. ஒவ்வொரு பிரிவிலும் காலணிகள், டி-ஷர்ட்கள் மற்றும் ஜாக்கெட்டுகள் போன்ற பல்வேறு வகையான தயாரிப்புகளுக்கு வெவ்வேறு பகுதிகள் உள்ளன. இவற்றை தொகுதிகளாகக் கருதுங்கள்.
பைத்தானில் தொகுப்புகளை எவ்வாறு உருவாக்குவது மற்றும் பயன்படுத்துவது என்று பார்ப்போம்.
முதலில், திட்டப் பலகத்தில் இருந்து புதிய கோப்பகத்தைச் சேர்க்கவும். அதை "இ-காமர்ஸ்" என்று அழைப்போம். இந்தத் தொகுப்பில் இணையவழி பயன்பாடு தொடர்பான அனைத்து தொகுதிக்கூறுகளும் இருக்கும்.
இது இன்னும் ஒரு வெற்று அடைவு மற்றும் அதை ஒரு தொகுப்பாக மாற்ற, அதில் ஒரு சிறப்பு கோப்பை உருவாக்க வேண்டும். இந்தக் கோப்பகத்தில் புதிய பைதான் கோப்பைச் சேர்த்து, அந்தக் கோப்பிற்கு “__init__” என்று பெயரிடவும். இது பைத்தானில் ஒரு சிறப்பு மாநாடு மற்றும் பைதான் மொழிபெயர்ப்பாளர் இந்த பெயருடன் ஒரு கோப்பை ஒரு கோப்பகத்தில் பார்க்கும்போது, அது இந்த கோப்பகத்தை ஒரு தொகுப்பாகக் கருதுகிறது.
எங்களிடம் ஒரு தொகுப்பை உருவாக்க மாற்று மற்றும் சுருக்கமான முறை உள்ளது. திட்டப் பலகத்தில் வலது கிளிக் செய்து, பட்டியலில் இருந்து பைதான் தொகுப்பை உருவாக்கவும். அதற்கு “இ-காமர்ஸ்” என்று பெயரிடுங்கள், அவ்வளவுதான். இது தானாகவே “__init__” என்ற பைதான் கோப்புடன் ஒரு கோப்பகத்தை உருவாக்கும்.
இப்போது, தொகுப்பில் ஒரு தொகுதியை உருவாக்கி அதற்கு "ஷிப்பிங்" என்று பெயரிடுவோம். இந்த தொகுதியில், கப்பல் செலவுகளைக் கணக்கிடுவதற்கான எளிய செயல்பாட்டை உருவாக்குவோம்.
def calc_shipping():
print("calc_shipping")
எங்கள் முக்கிய தொகுதியில் இந்த செயல்பாட்டை அணுக, நாம் அதை e-commerce தொகுப்பு மூலம் அணுக வேண்டும். இந்த தொகுதியை இறக்குமதி செய்ய மீண்டும் இரண்டு முறைகள் உள்ளன.
முதல் முறையில், நாம் முழு தொகுதியையும் இறக்குமதி செய்யலாம், பின்னர் இது போன்ற ஒரு செயல்பாட்டை சுயாதீனமாக அழைக்கலாம்:
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()
மடக்கு!
பைத்தானில் தொகுப்புகள் மற்றும் தொகுதிகள் மிகவும் முக்கியமானவை. குறிப்பாக, நீங்கள் கட்டுவதற்குப் பயன்படுத்தப்படும் ஜாங்கோ போன்ற கட்டமைப்புடன் வேலை செய்ய விரும்பும்போது வலை பயன்பாடுகள் பைத்தானுடன். மற்றொரு பைதான் பாடத்தின் போது ஜாங்கோவைப் பார்ப்போம்.
இந்தத் தொடரின் கடைசி வழக்கமான விரிவுரை இதுவாகும். அடுத்த விரிவுரை எங்கள் வழக்கமான வடிவமைப்பிலிருந்து விலகி, பைத்தானில் சில முக்கியமான பயன்பாட்டு நிகழ்வுகளைக் கற்றுக்கொள்வோம். அது இந்தத் தொடரின் முடிவைக் குறிக்கும், மேலும் நாங்கள் எங்கள் அடுத்த பைதான் தொடருக்குச் செல்வோம். அதற்காக காத்திருங்கள்.
ஒரு பதில் விடவும்