அறிக்கை என்றால் பைத்தானை எப்படி பயன்படுத்துவது

தி என்றால் அறிக்கை தருக்க நிரலாக்கத்தின் உந்து சக்தியாகும். இதன் விளைவாக, பைத்தானின் சிறந்த புரிதல் என்றால் உங்கள் பைதான் நிரலாக்க திறன்களுக்கு ஒரு குறிப்பிடத்தக்க கூடுதலாகும்.

பைத்தானைப் பற்றி மேலும் அறிய விரும்புகிறீர்களா? என்றால் அறிக்கை? கவலைப்பட வேண்டாம், இதை எப்படி பயன்படுத்துவது என்பதை இங்கே விளக்குகிறோம் என்றால் உங்கள் திட்டத்தைக் கட்டுப்படுத்த பைத்தானின் நிலை.

---

---

பைத்தானில் அறிக்கை எப்படி வேலை செய்கிறது

பொதுவாக, பைத்தானில் நிபந்தனை அறிக்கைகள் தொடங்குகின்றன என்றால் மற்றும் அது இல்லாமல், அவை தர்க்கரீதியாக இல்லை. இருப்பினும், நிபந்தனைகள் என்பது புரோகிராமரால் வரையறுக்கப்பட்ட விதிகளின் தொகுப்பாகும், இது ஒரு குறிப்பிட்ட நிகழ்வு உண்மையா பொய்யா என்று சோதிக்கிறது. சாராம்சத்தில், அவர்கள் ஒரு நிகழ்வின் செல்லுபடியை சரிபார்க்கிறார்கள்.

ஒரு என்றால் பைத்தானில் உள்ள அறிக்கை பொதுவாக இந்த வடிவத்தை எடுக்கும்:

if an event is True:
Execute some commands...


என்றாலும் என்றால் அறிக்கை தனியாக நிற்க முடியும், மற்ற நிபந்தனைகள் போன்றவை எலிஃப் , மற்றும் வேறு மற்ற விதிகளை வைக்க அதை காப்புப் பிரதி எடுக்க முடியும். எனினும், நீங்கள் போன்ற அறிக்கைகளையும் பயன்படுத்தலாம் இல்லை , மற்றும் , அல்லது , மற்றும் இல் உடன் என்றால் பைத்தானின் நிலை.

பைதான் நீங்கள் பயன்படுத்த அனுமதிக்கிறது என்றால் போன்ற கட்டுப்பாட்டு ஓட்டங்களுடன் அறிக்கை நேரடியாக க்கான வளையம். எப்படி பயன்படுத்துவது என்று பார்ப்போம் என்றால் கீழேயுள்ள எடுத்துக்காட்டுகளில் இந்த ஒவ்வொரு வழக்குகளுடனும் அறிக்கை.

பைதான் பயன்படுத்தினால் எப்படி ... வேறு அறிக்கைகள்

உடன் என்றால் நிபந்தனை, ஒரு நிகழ்வு உண்மையாக இருக்கும் வரை கட்டளைகளின் தொகுப்பை செயல்படுத்த பைத்தானிடம் சொல்லலாம்:

---

---

விண்டோஸ் 10 இணைய அணுகல் இல்லை என்பதை அடையாளம் காட்டுகிறது

if 5 > 3:
print('Valid')
Output: Valid


எனினும், ஒரு கலவையாகும் என்றால் வேறு முதல் கட்டம் தவறாக இருந்தால் நீங்கள் மற்றொரு கட்டளைகளை இயக்க வேண்டியிருக்கும் போது நிலைமைகள் பயனுள்ளதாக இருக்கும். இதை நடைமுறையில் பார்க்கலாம்:

a = 10
b = 3
if a == b:
print('They're the same')
else:
print('They're not the same')
Output: They're not the same


பைதான் பூலியன் மதிப்பை திருப்பித் தருவதன் மூலம் மேலே உள்ள இரண்டு மாறிகளின் சமத்துவத்தை நேரடியாகச் சரிபார்க்கலாம். உதாரணமாக, அச்சிடுதல் a == ஆ தவறானதைத் தருகிறது:

---

---

a = 10
b = 3
print(a==b)
Output: False


பைதான் என்றால் ... எலிஃப் ... மற்ற நிபந்தனைகளை எப்படி பயன்படுத்துவது

ஜாவாஸ்கிரிப்ட் போன்ற நிரலாக்க மொழிகள் பயன்படுத்தும்போது வேறு என்றால் , பைதான் பயன்படுத்துகிறது எலிஃப் . எனினும், ஒரு வேறு பொதுவாக பைத்தானில் ஒரு நிபந்தனை அறிக்கையின் தொகுப்பை முடிக்கிறது. ஆனால் உங்கள் நிபந்தனைகளை முடிப்பதற்கு முன்பு நீங்கள் மற்ற நிகழ்வுகளை சரிபார்க்க விரும்பினால், நீங்கள் இதைப் பயன்படுத்த வேண்டும் எலிஃப் அறிக்கை பைத்தானின் பயன்பாட்டு வழக்கைப் பார்ப்போம் எலிஃப் கீழே:

a = 10
b = 3
if b == a:
print(a + b)
elif b * a == 30:
print(b - a)
else:
print('impossible')
Output: -7


மேலே உள்ள குறியீட்டில், பைத்தான் கட்டளையை உள்ளே செயல்படுத்துகிறது என்றால் அது உண்மை என்றால் அறிக்கை. இல்லையென்றால், அது செயல்படுத்துகிறது எலிஃப் அறிக்கை இல்லையெனில், அது வெளியிடுகிறது வேறு அறிக்கை

நீங்கள் ஒன்றுக்கு மேற்பட்டவற்றைப் பயன்படுத்தலாம் எலிஃப் மற்றும் ஒரு வேறு பிற நிபந்தனைகளை வைக்க:

myList = ['Python', 'MUO', 'Hello']
if ('Python') in myList:
print('No')
elif 'N' in myList[1]:
print('MUO')
elif 'e' in myList[2]:
print('Hello')
else:
print('None is true')
Output: Hello


'இன்,' 'மற்றும், மற்றும்' அல்லது 'பைத்தானுடன் முக்கிய வார்த்தைகளை எப்படி பயன்படுத்துவது

நீங்கள் பயன்படுத்தலாம் இல் உடன் முக்கிய சொல் என்றால் ஒரு பட்டியல் ஒரு வரிசையில் அல்லது ஒரு வரிசையில் இருக்கிறதா என்று சரிபார்க்க அறிக்கை:

myList = ['Python', 'MUO', 'Hello']
if ('Python') in myList:
print('It's in the list')
Output: It's in the list


நீங்கள் இதைப் பயன்படுத்தலாம் மற்றும் உடன் வெளிப்பாடு என்றால் ஒரு பொருளை விட அதிகமாக சரிபார்க்க:

myList = ['Python', 'MUO', 'Hello']
if ('Python' and 'Hello') in myList:
print('Hello Python')
Output: Hello Python


தொடர்புடையது: பைட்டிங் ரெஜெக்ஸ் ஏமாற்றுத் தாள் வளரும் புரோகிராமர்களுக்கானது

பட்டியலில் ஏதேனும் பொருள் இருக்கிறதா என்று சோதிக்க, நீங்கள் இதைப் பயன்படுத்தலாம் அல்லது முக்கிய சொல்:

myList = ['Python', 'MUO', 'Hello']
if ('Python' or 'Bags') in myList:
print('One of them is on the list')
Output: One of them is on the list


வளையத்துடன் இருந்தால் பைத்தானை எவ்வாறு பயன்படுத்துவது

A இல் என்ன நடக்கிறது என்பதையும் நீங்கள் கட்டுப்படுத்தலாம் க்கான உடன் வளையம் என்றால் நிலை. உதாரணமாக, நீங்கள் நிபந்தனைகளை அமைக்கலாம் வளையத்திற்கான பைத்தானுடன் ஒரு பட்டியல் அல்லது வரிசை மூலம் சுழலும் . இது எப்படி வேலை செய்கிறது என்பதை அறிய கீழே உள்ள உதாரணக் குறியீட்டைப் பாருங்கள்:

myList = myList = ['Python', 'MUO', 'Hello']
myList2 = ['Fish', 'Gold', 'Bag']
if len(myList) == 3:
for items in myList:
print(items)
else:
for items2 in myList2:
print(items2)


மேலே உள்ள குறியீடு நீளத்தை சரிபார்க்கிறது myList அறிக்கை உண்மையாக இருந்தால் சரியாக மூன்று மற்றும் அதன் வழியாக சுழல்கிறது. இல்லையெனில், அது செயல்படுத்துகிறது வேறு அறிக்கை மற்றும் ஒவ்வொரு உருப்படியையும் வெளியிடுகிறது myList2 .

எனினும், நீங்கள் அந்த குறியீட்டை மாற்றியமைத்து, அனைத்து பட்டியலிலும் உள்ள அனைத்து உருப்படிகளையும் சரியாக நான்கு வார்த்தைகளுடன் அச்சிடலாம்:

myList = ['Python', 'MUO', 'Hello', 'Books', 'Pizza', 'Four']
myList2 = ['Fish', 'Gold', 'Bag']
for items in (myList + myList2):
if len(items) == 4:
print(items)


மேலே உள்ள குறியீடு முதலில் இரண்டு பட்டியல்களையும் ஒருங்கிணைக்கிறது. இரண்டு பட்டியல்களிலும் சரியாக நான்கு வார்த்தைக் கணக்குகளைக் கொண்ட உருப்படிகள் உள்ளதா என்பதைச் சரிபார்த்து, அறிக்கை உண்மையாக இருந்தால் அவற்றைத் திருப்புகிறது.

விண்டோஸ் 10 இல் ஒலி வேலை செய்யாது

பைதான் செயல்பாட்டில் if அறிக்கையை எவ்வாறு பயன்படுத்துவது

தி என்றால் பைத்தானில் ஒரு செயல்பாட்டை எழுதும் போது நிபந்தனையும் பயனுள்ளதாக இருக்கும். ஒரு எளிய குறியீட்டில் செய்வது போல, தி என்றால் ஒரு செயல்பாட்டில் என்ன நடக்கிறது என்பதை நிலை தீர்மானிக்க முடியும்.

தொடர்புடையது: பைத்தானில் உங்கள் சொந்த தொகுதியை எவ்வாறு உருவாக்குவது, இறக்குமதி செய்வது மற்றும் மீண்டும் பயன்படுத்துவது

எப்படி பயன்படுத்துவது என்று பார்ப்போம் என்றால் மேலே உள்ள முந்தைய பிரிவில் குறியீட்டின் கடைசி தொகுதியை மறுசீரமைப்பதன் மூலம் பைதான் செயல்பாட்டில் அறிக்கை மற்றும் பிற நிபந்தனைகள்:

def checkString(list1, list2):
for items in (list1 + list2):
if len(items) == 4:
print(items)
break
else:
print('impossible')
List1 = ['Python', 'MUO', 'Hello', 'Books', 'Pizza', 'Four']
List2 = ['Fish', 'Gold', 'Bag']
checkString(List, List2)


முந்தைய பிரிவில் உள்ள குறியீட்டைப் போலவே, மேலே உள்ள செயல்பாடு அனைத்து உருப்படிகளையும் சரியாக நான்கு வார்த்தைக் கணக்குகளுடன் வெளியிடுகிறது. எனினும், தி இடைவேளை நிபந்தனையை பூர்த்தி செய்யும் கடைசி உருப்படியை அச்சிட்ட பிறகு மரணதண்டனை நிறுத்தப்படுவதை அறிக்கை உறுதி செய்கிறது. நிகழ்வுக்குள் இருந்தால் என்றால் அறிக்கை தவறானது, தி வேறு நிபந்தனை அதற்குள் கட்டளையை செயல்படுத்துகிறது.

பைத்தானின் லாம்ப்டா செயல்பாட்டுடன் if அறிக்கையைப் பயன்படுத்துதல்

அநாமதேய லாம்ப்டா செயல்பாட்டுடன் நீங்கள் if அறிக்கையைப் பயன்படுத்தலாம். உங்களுக்கு தேவையானது ஒரு பைதான் லாம்ப்டா செயல்பாட்டின் அடிப்படை புரிதல் இதனை செய்வதற்கு.

இது எப்படி வேலை செய்கிறது என்பதைப் புரிந்து கொள்ள முந்தைய பகுதியில் செயல்பாட்டை ஒரு லாம்ப்டா செயல்பாடாக மீண்டும் எழுதுவோம்:

checkString = lambda a, b: [y for y in (a + b) if len(y) == 4]
print(checkString(List1, List2))
Output: ['Four', 'Fish', 'Gold']


மேலே உள்ள லாம்ப்டா செயல்பாடு முந்தைய பிரிவில் நாங்கள் பயன்படுத்திய சாதாரண செயல்பாட்டின் அதே வெளியீட்டை அளிக்கிறது. இருப்பினும், இங்கே, பைதான் பட்டியல் புரிதலை உருவாக்குவதன் மூலம் குறியீட்டை வெளிப்படுத்தினோம்.

பைதான் பட்டியல் புரிதலில் ஒரு if அறிக்கையை எவ்வாறு பயன்படுத்துவது

இதைப் பயன்படுத்தவும் முடியும் என்றால் உடன் அறிக்கை க்கான ஒரு பட்டியல் புரிதலில் வளைய. இந்த எடுத்துக்காட்டில், ஒரு பட்டியல் புரிதலில் நான்கு வார்த்தைகளுடன் அனைத்து உருப்படிகளையும் அச்சிடுவதற்கு முந்தைய குறியீட்டை மீண்டும் எழுதலாம்:

பல எக்செல் தாள்களை ஒன்றில் இணைக்கவும்

myList = ['Python', 'MUO', 'Hello', 'Books', 'Pizza', 'Four']
myList2 = ['Fish', 'Gold', 'Bag']
lis = [lists for lists in (myList + myList2) if len(lists) is 4]
print(lis)
Output: ['Four', 'Fish', 'Gold']


தொடர்புடையது: பைதான் பட்டியல் புரிதல்களை எவ்வாறு பயன்படுத்துவது (எப்போது அவற்றைப் பயன்படுத்தக்கூடாது)

நீங்களும் பயன்படுத்தலாம் என்றால் ... மற்றும் அல்லது என்றால் ... அல்லது ஒரு பட்டியல் புரிதலில். முதலில், பயன்பாட்டின் வழக்கைப் பார்ப்போம் என்றால் ... அல்லது பைதான் பட்டியல் புரிதலில்:

myList = ['Python', 'MUO', 'Hello', 'Books', 'Pizza', 'Four']
myList2 = ['Fish', 'Gold', 'Bag']
lis = [lists for lists in (myList + myList2) if ('P' in lists or 'F' in lists)]
print(lis)
Output: ['Python', 'Pizza', 'Four', 'Fish']


அவற்றில் 'பி' அல்லது 'எஃப்' எழுத்துக்கள் உள்ளதா என குறியீடு சரிபார்த்து, அறிக்கை உண்மையாக இருந்தால் அவற்றை வெளியிடுகிறது.

நாமும் பயன்படுத்தலாம் என்றால் ... மற்றும் 'பி' மற்றும் 'ஓ' ஆகிய இரண்டு சரங்களையும் கொண்ட பொருட்களை அச்சிட:

lis = [lists for lists in (myList + myList2) if ('P' in lists and 'o' in lists)]
print(lis)
Output: ['Python']


மேலே உள்ள குறியீடு 'பைதான்' ஐ மட்டுமே வெளியிடுகிறது, ஏனெனில் பட்டியலில் 'P' மற்றும் 'o' இரண்டுமே உள்ளது.

பைதான் பட்டியல் புரிதலில் இருந்தால் நெஸ்ட்டை எப்படி பயன்படுத்துவது

சில சந்தர்ப்பங்களில், நீங்கள் ஒரு கூட்டைப் பயன்படுத்தலாம் என்றால் ஒரு பட்டியலைப் புரிந்துகொள்ளும் நிலை. உள்ளமைவைப் பயன்படுத்தி மூன்று மற்றும் ஐந்தைப் பிரிக்கக்கூடிய அனைத்து எண்களையும் வெளியிடும் பட்டியல் புரிதலின் உதாரணத்தைப் பார்ப்போம். என்றால் நிபந்தனைகள்:

B = range(31)
A = [x for x in B if x % 3 == 0 if x % 5 ==0]
print(A)
Output: [0, 15, 30]


இருப்பினும், பட்டியலுக்குப் பதிலாக ஒரு தொகுப்பு புரிதலைப் பயன்படுத்தி மேற்கண்ட குறியீடு என்ன செய்கிறது என்பதை நீங்கள் செய்யலாம். ஆனால் இந்த முறை, உங்கள் வெளியீட்டை ஒரு செட் லிட்டரலாகப் பெறுவீர்கள்:

A = {x for x in B if x % 3 == 0 if x % 5 ==0}
print(A)
Output: {0, 30, 15}


மற்ற பட்டியல் புரிதல் எடுத்துக்காட்டுகளையும் புரிந்துகொள்ளும் வகையில் மாற்றுவதன் மூலம் விளையாடலாம்.

தருக்க அறிக்கைகள் பல தானியங்கி நிரல்களைக் கட்டுப்படுத்துகின்றன

தர்க்க அறிக்கைகள் இன்று பல குறியிடப்பட்ட நிரல்களின் கட்டுமானத் தொகுதிகள் ஆகும், மேலும் பைத்தானில் இயங்கும் நிரல்களுக்கு இது வேறுபட்டதல்ல. எவ்வாறாயினும், நாங்கள் முன்பு கூறியது போல், நிபந்தனை அறிக்கைகள் உங்கள் குறியீட்டை நன்கு புரிந்துகொள்ளும், எனவே நீங்கள் விரும்பும் வகையில் விஷயங்களை மாற்றியமைக்கலாம்.

கேம் டெவலப்மென்ட், மெஷின் லேர்னிங் மற்றும் வெப் டெவலப்மென்ட் போன்ற நிஜ வாழ்க்கை திட்டங்கள் டாஸ்க் ஆட்டோமேஷனுக்கான இந்த நிபந்தனை அறிக்கைகளைப் பொறுத்தது, அவை பயனர்களுக்கு விரும்பிய வெளியீடுகளுடன் சேவை செய்ய அனுமதிக்கிறது. எனவே, வரவிருக்கும் புரோகிராமராக, அவர்களைப் பற்றியும் மேலும் அவர்கள் எவ்வாறு செயல்படுகிறார்கள் என்பதையும் மேலும் அறிந்து கொள்வது, டைனமிக் மற்றும் பதிலளிக்கக்கூடிய நவீன தொழில்நுட்பத் திட்டங்களை குறியாக்க அவசியம்.

பகிர் பகிர் ட்வீட் மின்னஞ்சல் பைத்தானில் ஒரு நேர சுழற்சியை எவ்வாறு பயன்படுத்துவது

குறியீடுகளில் சுழல்கள் ஒரு அடிப்படை பகுதியாக இருந்தாலும், அவற்றை எவ்வாறு சிறப்பாகப் பயன்படுத்துவது என்பதை இங்கே கற்றுக்கொள்ளுங்கள்.

அடுத்து படிக்கவும் தொடர்புடைய தலைப்புகள்

• நிரலாக்க
• பைதான்

எழுத்தாளர் பற்றி இடிசோ ஒமிசோலா(94 கட்டுரைகள் வெளியிடப்பட்டன)

இடோவு ஸ்மார்ட் தொழில்நுட்பம் மற்றும் உற்பத்தித்திறன் ஆகியவற்றில் ஆர்வம் கொண்டவர். அவரது ஓய்வு நேரத்தில், அவர் சலிப்படையும்போது குறியீட்டுடன் விளையாடுகிறார் மற்றும் சதுரங்கப் பலகைக்கு மாறுகிறார், ஆனால் அவர் எப்போதாவது வழக்கத்திலிருந்து விலகிச் செல்ல விரும்புகிறார். நவீன தொழில் நுட்பத்தை மக்களுக்கு காட்டும் ஆர்வம் அவரை மேலும் எழுத தூண்டுகிறது.

இடோவு ஒமிசோலாவில் இருந்து மேலும்

எங்கள் செய்திமடலுக்கு குழுசேரவும்

தொழில்நுட்ப குறிப்புகள், மதிப்புரைகள், இலவச மின் புத்தகங்கள் மற்றும் பிரத்யேக ஒப்பந்தங்களுக்கு எங்கள் செய்திமடலில் சேரவும்!

குழுசேர இங்கே சொடுக்கவும்