പ്രവർത്തനങ്ങൾ

ആമുഖം

പൈത്തൺ പ്രോഗ്രാമിംഗിന്റെ അടിസ്ഥാന ഘടകമാണ് ഫംഗ്‌ഷനുകൾ, ഒരു പ്രത്യേക ജോലി നിർവഹിക്കുന്നതിനായി രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്ന കോഡിന്റെ പുനരുപയോഗിക്കാവുന്നതും കാര്യക്ഷമവുമായ വിഭാഗങ്ങളിലേക്ക് കോഡ് സ്‌നിപ്പെറ്റുകൾ പാക്കേജുചെയ്യുന്നു. ഒരു പ്രോഗ്രാമിനുള്ളിൽ ഫംഗ്‌ഷനുകളെ ഒന്നിലധികം തവണ വിളിക്കാൻ കഴിയും, ഇത് കോഡ് ഓർഗനൈസേഷൻ എളുപ്പമാക്കുന്നു, കൂടാതെ ആവർത്തിച്ചുള്ള കോഡ് ഒഴിവാക്കാൻ സഹായിക്കുന്നു. ഫംഗ്‌ഷനുകൾ കോഡിനെ ഡീബഗ് ചെയ്യുന്നത് എളുപ്പമാക്കുന്നു.

പ്രധാനം: ഒരു ഫംഗ്ഷൻ നിർവചിച്ചതുകൊണ്ട് മാത്രം അത് റൺ ആകില്ല. ഒരു പുതിയ ത്രെഡിൽ ഒരു ഫംഗ്ഷൻ ആരംഭിക്കാൻ start_thread ഉപയോഗിക്കുക, അങ്ങനെ ഒരു ഇവന്റിനോ കോൾബാക്കിനോ വേണ്ടി കാത്തിരിക്കുന്നതിനുപകരം, പ്രോജക്റ്റിന്റെ തുടക്കത്തിൽ തന്നെ അത് പ്രവർത്തിക്കാൻ തുടങ്ങും.

• def ഒരു ഫംഗ്ഷനെ നിർവചിക്കുന്നു.

• return ഫംഗ്ഷന്റെ ഔട്ട്‌പുട്ട് പ്രധാന പ്രോഗ്രാമിലേക്ക് തിരികെ അയയ്ക്കുന്നു.

ഉപയോഗം:

def function_name(parameters):
    # Code to execute when the function is called
    return result  # Optional, used to return a value

പാരാമീറ്ററുകൾ	വിവരണം
function_name	നിങ്ങളുടെ ഫംഗ്ഷന് നിങ്ങൾ നൽകുന്ന ഒരു പേര്.
parameters	ഓപ്ഷണൽ. ഫംഗ്ഷൻ വിളിക്കുമ്പോൾ ഇൻപുട്ട് മൂല്യങ്ങൾ സ്വീകരിക്കുന്ന വേരിയബിളുകൾ, ഫംഗ്ഷനിലേക്ക് ഡാറ്റ കൈമാറാൻ അനുവദിക്കുന്നു.
result	ഓപ്ഷണൽ. ഫംഗ്ഷൻ കോളറിലേക്ക് ഒരു ഫലം തിരികെ അയയ്ക്കാൻ അനുവദിക്കുന്നു. ഒരു ഫംഗ്ഷനിൽ ഒരു റിട്ടേൺ സ്റ്റേറ്റ്മെന്റ് ഉൾപ്പെടുത്തിയിട്ടില്ലെങ്കിൽ, അത് സ്ഥിരസ്ഥിതിയായി None തിരികെ നൽകും.

Note: A function must always be defined before it is called.

ഫംഗ്ഷനുകൾ നിർവചിക്കലും വിളിക്കലും

Functions with No Parameters

ഒരു ഫംഗ്ഷന് ഇൻപുട്ട് ആവശ്യമില്ലെങ്കിൽ, പാരാമീറ്ററുകൾ ഇല്ലാതെ തന്നെ നിങ്ങൾക്ക് അത് നിർവചിക്കാൻ കഴിയും.

def greeting():
    console.print("Hello!")

def main():
    # Call the greeting function
    greeting()

# Start threads — Do not delete
start_thread(main)

Functions with Parameters

ഫംഗ്ഷനുകളിലേക്ക് നിങ്ങൾക്ക് പാരാമീറ്ററുകൾ ചേർക്കാനും കഴിയും, അത് ഫംഗ്ഷൻ പ്രവർത്തിക്കാൻ ആവശ്യമായ വിവരങ്ങൾ കൈമാറാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

# Build Used: Super Code Base 2.0
def move_square(moves):
    for index in range(moves):
        drivetrain.drive_for(FORWARD, 150)
        drivetrain.turn_for(RIGHT, 90)

def main():
    # Call the move_square function
    move_square(4)
    

# Start threads — Do not delete
start_thread(main)

Functions with Default Arguments

ഒരു ഡിഫോൾട്ട് ആർഗ്യുമെന്റ് എന്നത് ഒരു പാരാമീറ്ററാണ്, അത് ആ ആർഗ്യുമെന്റിനുള്ള ഫംഗ്ഷൻ കോളിൽ ഒരു മൂല്യം നൽകിയിട്ടില്ലെങ്കിൽ അത് ഒരു ഡിഫോൾട്ട് മൂല്യം അനുമാനിക്കുന്നു.

# Build Used: Super Code Base 2.0
def move_square(moves=4):
    for index in range(moves):
        drivetrain.drive_for(FORWARD, 150)
        drivetrain.turn_for(RIGHT, 90)

def main():
    # Call the move_square function
    move_square()
    

# Start threads — Do not delete
start_thread(main)

Return Values from Functions

return കീവേഡ് ഉപയോഗിച്ച് ഫംഗ്ഷനുകൾക്ക് കോളറിലേക്ക് ഡാറ്റ തിരികെ അയയ്ക്കാൻ കഴിയും. ഇത് നിങ്ങളുടെ പ്രോഗ്രാമിലെ ഔട്ട്‌പുട്ട് പിടിച്ചെടുക്കാനും ഉപയോഗിക്കാനും നിങ്ങളെ അനുവദിക്കുന്നു.

def times_two(number):
    return number * 2

def main():
    # Display the return value
    console.print(times_two(2))

# Start threads — Do not delete
start_thread(main)

സ്റ്റാർട്ട്_ത്രെഡ്

start_thread ഒരു പുതിയ ത്രെഡിൽ ഒരു ഫംഗ്ഷൻ ആരംഭിക്കുന്നു, അങ്ങനെ അത് പ്രോജക്റ്റിന്റെ തുടക്കത്തിൽ തന്നെ പ്രവർത്തിക്കാൻ തുടങ്ങുന്നു.

ഒന്നിൽ കൂടുതൽ start_thread ഉപയോഗിച്ചിട്ടുണ്ടെങ്കിൽ, ഫംഗ്ഷനുകൾ ഒരേസമയം പ്രവർത്തിക്കും.

Usage:
start_thread(function)

പാരാമീറ്ററുകൾ	വിവരണം
function	മുമ്പ് നിർവചിച്ച ഒരു ഫംഗ്ഷന്റെ പേര്.

# Build Used: Super Code Base 2.0
def move_square():
    # Move in a square path
    while True:
        drivetrain.drive_for(FORWARD, 150)
        drivetrain.turn_for(RIGHT, 90)

def led_lights():
    # Blink LED lights
    while True:
        bumper.set_color(GREEN)
        wait(0.5, SECONDS)
        bumper.set_color(RED)
        wait(0.5, SECONDS)

# Start threads — Do not delete
start_thread(move_square)
start_thread(led_lights)