19: ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനുകൾ

പൈത്തൺ ധാരാളം ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനുകൾ തയ്യാറാക്കി വെച്ചിട്ടുണ്ട് — പ്രത്യേകമായി import ചെയ്യാതെ തന്നെ എപ്പോഴും ഉപയോഗിക്കാവുന്നവ. ഇവയിൽ പലതും (print(), len(), type()) നിങ്ങൾ ഇതിനകം ഉപയോഗിച്ചു കഴിഞ്ഞു. ഈ അധ്യായത്തിൽ ഏറ്റവും ഉപയോഗപ്രദമായവ ഒരുമിച്ച് കാണാം.

സാധാരണ ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനുകൾ

ഫംഗ്ഷൻഎന്ത് ചെയ്യുന്നുഉദാഹരണം
print()സ്ക്രീനിൽ കാണിക്കുന്നുprint("Hi")
len()നീളം/എണ്ണം കണ്ടെത്തുന്നുlen([1,2,3]) → 3
type()ഡാറ്റാ തരം കാണിക്കുന്നുtype(5) →
str(), int(), float()തരങ്ങൾക്കിടയിൽ പരിവർത്തനംint("10") → 10
sum()ഒരു ലിസ്റ്റിലെ സംഖ്യകൾ കൂട്ടുന്നുsum([1,2,3]) → 6
max(), min()ഏറ്റവും വലുത്/ചെറുത് കണ്ടെത്തുന്നുmax([5,10,2]) → 10
round()ഏറ്റവും അടുത്ത സംഖ്യയിലേക്ക് റൗണ്ട് ചെയ്യുന്നുround(3.6) → 4
abs()സമ്പൂർണ്ണ (നെഗറ്റീവ് അല്ലാത്ത) മൂല്യംabs(-10) → 10
sorted()ഒരു പുതിയ സോർട്ട് ചെയ്ത ലിസ്റ്റ് നൽകുന്നുsorted([3,1,2]) → [1,2,3]
range()സംഖ്യകളുടെ ഒരു ശ്രേണി സൃഷ്ടിക്കുന്നുrange(1,4) → 1, 2, 3
list(), tuple(), dict(), set()ഡാറ്റാ സ്ട്രക്ചറുകളിലേക്ക് പരിവർത്തനംlist((1,2)) → [1, 2]
enumerate()ഇൻഡെക്സും മൂല്യവും ഒരുമിച്ച് നൽകുന്നുപട്ടിക 10-ൽ കണ്ടു
zip()ഒന്നിലധികം ലിസ്റ്റുകളെ ജോഡികളാക്കുന്നുതാഴെ കാണാം
numbers = [5, 10, 2, 8]

print(sum(numbers))
print(max(numbers))
print(min(numbers))
print(sorted(numbers))

ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനുകൾ vs മെത്തേഡുകൾ

ഇവ രണ്ടും ആശയക്കുഴപ്പം ഉണ്ടാക്കാം, പക്ഷേ വ്യത്യാസം ലളിതമാണ്: ഒരു ബിൽറ്റ്-ഇൻ ഫംഗ്ഷൻ, വേരിയബിളിനെ ഒരു ആർഗ്യുമെന്റായി കൊടുത്താണ് വിളിക്കുന്നത് (len(fruits)). ഒരു മെത്തേഡ്, ഒരു നിശ്ചിത ഒബ്ജക്റ്റിനോട് ഡോട്ട് ഉപയോഗിച്ച് ചേർത്ത് വിളിക്കുന്നു (fruits.append("x")).

numbers = [3, 1, 2]

new_list = sorted(numbers)   # ബിൽറ്റ്-ഇൻ ഫംഗ്ഷൻ — പുതിയ ലിസ്റ്റ് നൽകുന്നു
print(new_list)
print(numbers)                # ഒറിജിനൽ ലിസ്റ്റ് മാറിയിട്ടില്ല

numbers.sort()                # മെത്തേഡ് — ഒറിജിനൽ ലിസ്റ്റ് തന്നെ മാറ്റുന്നു
print(numbers)

ഫംഗ്ഷനുകൾ സംയോജിപ്പിക്കുന്നു

ഒരു ഫംഗ്ഷന്റെ ഫലം, മറ്റൊരു ഫംഗ്ഷന്റെ ആർഗ്യുമെന്റായി നേരിട്ട് കൊടുക്കാം.

numbers = [3, 5, 1, 9]

average = round(sum(numbers) / len(numbers), 2)
print(average)

`zip()`: രണ്ട് ലിസ്റ്റുകൾ ജോഡിയാക്കുന്നു

രണ്ട് ലിസ്റ്റുകളിലെ ഇനങ്ങൾ, ഒരേ സ്ഥാനത്തുള്ളവ ജോഡിയാക്കി ഒരുമിച്ച് ലൂപ്പ് ചെയ്യാൻ zip() ഉപയോഗിക്കാം.

names = ["Anu", "Ravi", "Meera"]
marks = [90, 75, 82]

for name, mark in zip(names, marks):
	print(name, ":", mark)

യഥാർത്ഥ ജീവിത ഉദാഹരണം: ഗ്രേഡ് കാൽക്കുലേറ്റർ

marks = [78, 85, 90, 66]

total = sum(marks)
average = round(total / len(marks), 2)

print("Total:", total)
print("Average:", average)
print("Highest:", max(marks))
print("Lowest:", min(marks))

സാധാരണ തുടക്കക്കാരുടെ തെറ്റുകൾ

  • sorted(list)-ഉം list.sort()-ഉം ഒരേ കാര്യമാണ് എന്ന് കരുതുന്നു — ആദ്യത്തേത് പുതിയ ലിസ്റ്റ് നൽകുന്നു, രണ്ടാമത്തേത് ഒറിജിനൽ ലിസ്റ്റ് മാറ്റുന്നു
  • round() എപ്പോഴും മുകളിലേക്ക് റൗണ്ട് ചെയ്യും എന്ന് കരുതുന്നു (round(2.5) യഥാർത്ഥത്തിൽ 2 ആകാം, പൈത്തണിന്റെ റൗണ്ടിംഗ് നിയമം കാരണം)
  • ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനും മെത്തേഡും ഒരേ രീതിയിൽ വിളിക്കാൻ ശ്രമിക്കുന്നു (ഉദാ: sort(numbers) എന്ന് എഴുതി പിശക് വരുത്തുന്നു, ശരിയായത് numbers.sort())

ഈ അധ്യായത്തിന്റെ സംഗ്രഹം

  • sum(), max(), min(), round(), abs(), sorted() തുടങ്ങിയ ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനുകൾ പഠിച്ചു
  • ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനും മെത്തേഡും തമ്മിലുള്ള വ്യത്യാസം മനസ്സിലാക്കി
  • ഫംഗ്ഷനുകൾ ഒന്നിനുള്ളിൽ ഒന്നായി സംയോജിപ്പിച്ചു
  • zip() ഉപയോഗിച്ച് രണ്ട് ലിസ്റ്റുകൾ ജോഡിയാക്കി
  • ഒരു ഗ്രേഡ് കാൽക്കുലേറ്റർ ഉദാഹരണം ഉണ്ടാക്കി

വ്യായാമങ്ങൾ

  • 5 സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് സൃഷ്ടിച്ച്, അതിന്റെ ആകെ തുകയും ശരാശരിയും (2 ദശാംശ സ്ഥാനം വരെ റൗണ്ട് ചെയ്ത്) പ്രിന്റ് ചെയ്യുക
  • രണ്ട് ലിസ്റ്റുകൾ (പേരുകൾ, നഗരങ്ങൾ) zip() ഉപയോഗിച്ച് ജോഡിയാക്കി, ഓരോ ജോഡിയും പ്രിന്റ് ചെയ്യുക
  • ഒരു ലിസ്റ്റ് സൃഷ്ടിച്ച്, sorted() ഉപയോഗിച്ച് ഒരു പുതിയ സോർട്ട് ചെയ്ത പകർപ്പ് ഉണ്ടാക്കി, ഒറിജിനൽ ലിസ്റ്റ് മാറിയിട്ടില്ല എന്ന് തെളിയിക്കുക

Quiz & Self Assessment

ചോദ്യം 1 / 4
sum([2, 4, 6]) എന്നതിന്റെ ഫലം എന്താണ്?

അടുത്ത അധ്യായത്തിൽ, കോഡ് വീണ്ടും എഴുതാതെ കൂടുതൽ ചെയ്യാൻ സഹായിക്കുന്ന മൊഡ്യൂളുകളും പാക്കേജുകളും നിങ്ങൾ പഠിക്കും.