வேகமாக கற்றுக்கொள்ள உதவும் 10 அடிப்படை பைதான் உதாரணங்கள்

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

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

---

---

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

சரங்கள்

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

சரம் வடிவமைத்தல்

உங்களிடம் இரண்டு சரங்கள் உள்ளன என்று வைத்துக்கொள்வோம்:

தெரியாத யுஎஸ்பி சாதனம் (சாதன விளக்க கோரிக்கை தோல்வியடைந்தது) விண்டோஸ் 10

>>>name = 'Joel'
>>>job = 'Programmer'

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

>>>title = name + ' the ' + job
>>>title
>'Joel the Programmer'

ஆனால் இது பைத்தானிக் என்று கருதப்படவில்லை. இன்னும் படிக்கக்கூடிய குறியீட்டை விளைவிக்கும் சரங்களை கையாள விரைவான வழி உள்ளது. பயன்படுத்த விரும்புகின்றனர் வடிவம் () முறை:

---

---

>>>title = '{} the {}'.format(name, job)
>>>title
>'Joel the Programmer'

தி {} அளவுருக்கள் மூலம் மாற்றப்படும் ஒரு ஒதுக்கிடமாகும் வடிவம் () தொடர் வரிசையில் முறை. முதல் {} பெயர் அளவுருவாகவும், இரண்டாவது {} வேலை அளவுருவாகவும் மாற்றப்படும். எண்ணிக்கை பொருந்தும் வரை நீங்கள் விரும்பும் பல {} கள் மற்றும் அளவுருக்களை வைத்திருக்கலாம்.

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

---

---

>>>age = 28
>>>title = '{} the {} of {} years'.format(name, job, age)
>>>title
>'Joel the Programmer of 28 years'

சரம் சேரும்

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

>>>availability = ['Monday', 'Wednesday', 'Friday', 'Saturday']
>>>result = ' - '.join(availability)
>>>result
>'Monday - Wednesday - Friday - Saturday'

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

நிபந்தனைகள்

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

பூலியன் மதிப்புகள்

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

>>>x = 10
>>>print(x == 10) # True
>>>print(x != 10) # False
>>>print(x 10) # False, same as != operator
>>>print(x > 5) # True
>>>print(x <15) # True
>>>print(x >= 10) # True
>>>print(x <= 10) # True

ஆபரேட்டர்கள் மற்றும் இல்லை

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

>>>a = [1,2,3]
>>>b = [1,2,3]
>>>c = a
>>>print(a == b) # True
>>>print(a is b) # False
>>>print(a is c) # True

ஒரு பூலியன் மதிப்பை அதற்கு முன்னால் நிராகரிக்கலாம் இல்லை ஆபரேட்டர்:

>>>a = [1,2,3]
>>>b = [1,2,3]
>>>if a is not b:
>>> # Do something here >>>x = False
>>>if not x:
>>> # Do something here

இன் ஆபரேட்டர்

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

>>>availability = ['Monday', 'Tuesday', 'Friday']
>>>request = 'Saturday'
>>>if request in availability:
>>> print('I'm available on that day!')

சிக்கலான நிபந்தனைகள்

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

>>>legs = 8
>>>habitat = 'Land'
>>>if legs == 8 and habitat == 'Land':
>>> species = 'Spider' >>>weather = 'Sunny'
>>>if weather == 'Rain' or weather == 'Snow':
>>> umbrella = True
>>>else:
>>> umbrella = False

கடைசி உதாரணத்தை நீங்கள் இன்னும் சுருக்கலாம்:

>>>weather = 'Sunny'
>>>umbrella = weather == 'Rain' or weather == 'Snow'
>>>umbrella
>False

சுழல்கள்

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

>>>i = 0
>>>while i <10:
>>> print(i)
>>> i = i + 1

இதுவும் இப்படி கட்டமைக்கப்படலாம்:

>>>i = 0
>>>while True:
>>> print(i)
>>> if i >= 10:
>>> break

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

தி லூப்

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

சுருக்கமாக, ஃபார் லூப் ஒரு இட்ரேபிள் பொருளின் மேல் (ஒரு பட்டியல் அல்லது அகராதி போன்றது) பயன்படுத்தி திரும்புகிறது இல் ஆபரேட்டர்:

>>>weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
>>>for day in weekdays:
>>> print(day)

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

X அளவு மறு செய்கைகளுக்கு நீங்கள் ஒரு வளையத்தை இயக்க விரும்பினால், பைதான் ஒரு வழங்குகிறது சரகம்() இந்த நோக்கத்திற்காக மட்டுமே முறை:

>>># Prints 0,1,2,3,4,5,6,7,8,9
>>>for i in range(10):
>>> print(i)

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

>>># Prints 5,6,7,8,9
>>>for i in range(5, 10):
>>> print(i)

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

>>># Prints 5,7,9
>>>for i in range(5, 10, 2):
>>> print(i)

எண்கள்

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

>>>weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
>>>for i, day in enumerate(weekdays):
>>> print('{} is weekday {}'.format(day, i))

இதன் விளைவாக:

>Monday is weekday 0
>Tuesday is weekday 1
>Wednesday is weekday 2
>Thursday is weekday 3
>Friday is weekday 4

ஒப்பிடுகையில், இதைச் செய்வதற்கான வழி இதுவல்ல:

>>>i = 0
>>>for day in weekdays:
>>> print('{} is weekday {}'.format(day, i))
>>> i = i + 1

சங்கச் சொல்லடைவு அகராதி

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

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

வெற்று ஆணையை எப்படி அறிவிப்பது:

>>>d = {}

ஒரு மதிப்புக்கு ஒரு டிக்ட் விசையை ஒதுக்குவது எப்படி:

>>>d = {}
>>>d['one_key'] = 10
>>>d['two_key'] = 25
>>>d['another_key'] = 'Whatever you want'

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

>>>d = {
>>> 'one_key': 10,
>>> 'two_key': 25,
>>> 'another_key': 'Whatever you want'
>>>}

விசை மூலம் ஒரு டிக்ட் மதிப்பை அணுக:

>>>d['one_key']
>10
>>>d['another_key']
>'Whatever you want'
>>>d['one_key'] + d['two_key']
>35

ஒரு ஆணையின் மீது மீண்டும் செய்ய, இது போன்ற ஒரு வளையத்தைப் பயன்படுத்தவும்:

>>>for key in d:
>>> print(key)

விசைகள் மற்றும் மதிப்புகள் இரண்டையும் மீண்டும் செய்ய, இதைப் பயன்படுத்தவும் பொருட்களை() முறை:

>>>for key, value in d.items():
>>> print(key, value)

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

>>>del d['one_key']

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

>>>capitals = {
>>> 'Alabama': 'Montgomery',
>>> 'Alaska': 'Juneau',
>>> 'Arizona': 'Phoenix',
>>> ...
>>>}

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

>>>state = 'Pennsylvania'
>>>capitals[state]
>'Harrisburg'

பைதான் கற்றுக் கொண்டே இருங்கள்: இது மதிப்புக்குரியது!

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

துரதிருஷ்டவசமாக கூகுள் பிளே சேவைகள் நிறுத்தப்பட்டுள்ளன

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

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

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

பகிர் பகிர் ட்வீட் மின்னஞ்சல் 6 கேட்கக்கூடிய மாற்று: சிறந்த இலவச அல்லது மலிவான ஆடியோபுக் ஆப்ஸ்

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

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

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

எழுத்தாளர் பற்றி ஜோயல் லீ(1524 கட்டுரைகள் வெளியிடப்பட்டன)

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

ஜோயல் லீயின் மேலும்

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

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

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