آموزش کار با توابع در پایتون – راهنمای جامع

توابع پایتون بلوک‌هایی از کد سازمان‌یافته و قابل‌استفاده مجدد هستند که وظایف خاصی را انجام می‌دهند. هدف آن‌ها کپسوله کردن اقدامات مکرر یا تکراری است که به ما این امکان را می‌دهد که به‌جای تکرار کد مشابه برای ورودی‌های مختلف، تابع را فراخوانی کنیم. با انجام این کار، می‌توانیم خوانایی کد را افزایش داده و قابلیت استفاده مجدد کد را ارتقا دهیم و برنامه‌هایمان را کارآمدتر و نگهداری آن‌ها را آسان‌تر کنیم. در این راهنمای جامع به عنوان مکمل دوره بالا شیوه کار با توابع در پایتون را شرح دهیم.

آموزش تابع نویسی در پایتون

آموزش تابع نویسی در پایتون به فرآیند آموزش و راهنمایی افراد در مورد نحوه ایجاد تابع و استفاده از آن در زبان برنامه ‌نویسی پایتون اشاره دارد. این شامل توضیح سینتکس، ساختار و مفاهیم مرتبط با توابع و تشریح کار توابع است تا کاربران بتوانند به‌طور مؤثری توابع خود را برای انجام وظایف خاص در برنامه‌های خود تعریف کنند.

جنبه‌های کلیدی کار با توابع در پایتون به‌صورت موارد زیر هستند که باید با آن‌ها آشنا باشیم.

• تعریف تابع: آشنایی کاربران با سینتکس تعریف یک تابع در پایتون با استفاده از کلمه کلیدی def و به دنبال آن نام تابع، پارامترها (در صورت وجود) و یک علامت دونقطه.
• پارامترهای تابع و آرگومان‌ها: توضیح مفاهیم پارامترها و آرگومان‌های تابع، نحوه انتقال داده‌ها به یک تابع و نحوه کار با مقادیر پیش‌فرض برای پارامترها.
• بدنه تابع: شامل نحوه نوشتن کد در بدنه تابع و توضیح اهمیت تورفتگی برای تعریف محدوده تابع.
• دستور بازگشت: بحث در مورد دستور بازگشت و نقش آن در تعیین مقداری که تابع خروجی می‌دهد یا نتیجه محاسبه آن.
• فراخوانی تابع: نشان دادن نحوه فراخوانی یک تابع و توضیح چگونگی تطبیق آرگومان‌های ارائه‌شده در طول فراخوانی تابع با پارامترهای تعریف شده در تعریف تابع.
• متغیرهای محلی: معرفی مفهوم متغیرهای محلی درون توابع که فقط در محدوده تابع قابل‌دسترسی هستند.
• Function Docstring: تشویق کاربران به مستندسازی (کامنت گذاری) توابع خود با استفاده از رشته‌های مستند، ارائه اطلاعات در مورد هدف، پارامترها و مقادیر بازگشتی تابع.
• محدوده تابع و متغیرهای سراسری: توضیح محدوده متغیرهای درون توابع و نحوه کار با متغیرهای سراسری در صورت لزوم.
• ترکیب توابع: نشان دادن اینکه چگونه توابع را می‌توان با فراخوانی یک تابع از دیگری ترکیب کرد و امکان ساخت عملکردهای پیچیده‌تر را فراهم می‌کند.
• توابع لامبدا (اختیاری): معرفی توابع لامبدا که با نام توابع ناشناس نیز شناخته می‌شوند که برای کارهای ساده استفاده شده و با کلمه کلیدی def تعریف نمی‌شوند.

در طول فرآیند کار با توابع در پایتون، مثال‌ها، تمرین‌ها و ابعاد مختلف آن‌ها ارائه می‌شود. با تسلط بر بحث تابع در پایتون، کاربران می‌توانند قدرت ماژولار بودن کد و قابلیت استفاده مجدد بودن کدهای خود را بهتر درک کنند.

آموزش توابع در پایتون

در این از آموزش کار با توابع در پایتون بخش به‌صورت عملی و قدم‌به‌قدم تمام جنبه‌های توابع پایتون را بررسی خواهیم کرد. سینتکس اعلام یک تابع در پایتون به‌صورت زیر است:

def function_name(parameters):‎

 # Function body (contains the code to be executed)

 return value # Optional - used to return a value from the function

توضیح هر قسمت:

• def: در تابع def نوعی کلمه کلیدی است که برای نشان دادن شروع یک اعلان تابع استفاده می‌شود.
• function_name: این شناسه یا نام تابع است. از قوانین و قراردادهای نام‌گذاری پایتون پیروی می‌کند. نام تابع باید توصیفی و منعکس کننده هدف تابع باشد.
• پارامترها: این‌ها ورودی‌های اختیاری هستند که تابع می‌تواند آن‌ها را بپذیرد. پارامترها در داخل پرانتز () قرار می‌گیرند. اگر تابع به هیچ ورودی نیاز نداشته باشد، پرانتزها را می‌توان خالی گذاشت.
• Function Body: این بلوک کدی است که عملکرد تابع را تعریف می‌کند. زیر دستور def تورفتگی دارد و حاوی دستورالعمل‌هایی است که هنگام فراخوانی تابع اجرا می‌شوند.
• return: از این کلمه کلیدی برای تعیین مقداری استفاده می‌شود که تابع هنگام فراخوانی آن را برمی‌گرداند. این قسمت اختیاری است؛ در صورت عدم استفاده، تابع به‌طور پیش‌فرض None را برمی‌گرداند. اگر تابعی دستور بازگشتی نداشته باشد، در انتها یک بازگشت ضمنی در نظر گرفته می‌شود. در اینجا یک مثال از یک تابع با پارامترها و یک دستور بازگشت آورده شده است:

def add_numbers(x, y):‎

 result = x + y

 return result

در این مثال، تابع add_numbers نام دارد و دو پارامتر x و y را می‌گیرد. بدنه تابع این دو پارامتر را اضافه کرده و نتیجه را در متغیر نتیجه ذخیره می‌کند. درنهایت، دستور return برای برگرداندن مقدار نتیجه به‌عنوان خروجی تابع استفاده می‌شود. به یاد داشته باشید که تورفتگی مناسب در پایتون برای نشان دادن محدوده توابع مهم است. کد داخل بدنه تابع باید تورفتگی داشته باشد تا آن را از سایر قسمت‌های برنامه متمایز کند.

چگونه در پایتون تابع بنویسیم؟

در پایتون، توابع تعریف‌شده توسط کاربر با استفاده از کلمه کلیدی def ایجاد می‌شوند و به ما امکان می‌دهند تا عملکردها و ویژگی‌های خاصی را در صورت نیاز کپسوله کنیم. مثال زیر از کار با توابع در پایتون برای این هدف آورده شده است:

def welcome_message():‎

 print("Welcome to Makhtabkhooneh")

welcome_message()‎

در کد بالا یک تابع تعریف شده توسط کاربر به نام welcome_message تعریف کرده‌ایم. این تابع هیچ پارامتری را دریافت نمی‌کند (چون هیچ پرانتزی بعد از نام تابع وجود ندارد) و هدف آن نمایش پیام Welcome to Makhtabkhooneh در هنگام فراخوانی است.

مثال تابع در پایتون

در اینجا دو مثال مختلف از نحوه کار با توابع در پایتون آورده شده است:

مثال ١: تابع محاسبه مساحت دایره که قطعه کد آن به‌صورت زیر است:

import math

def calculate_circle_area(radius):‎

 area = math.pi * radius**2

 return area

radius = 5

area_of_circle = calculate_circle_area(radius)

print(f"The area of the circle with radius {radius} is: {area_of_circle:.2f}")

مثال ٢: بررسی اول بودن اعداد که قطعه کد آن به‌صورت زیر است:

def is_prime(number):‎

 if number < 2:‎

 return False

 for i in range(2, int(number**0.5) + 1):‎

 if number % i == 0:‎

 return False

 return True

# Checking if a number is prime

num = 17

if is_prime(num):‎

 print(f"{num} is a prime number.")

else:‎

 print(f"{num} is not a prime number.")

این مثال‌ها نشان می‌دهند که چگونه توابع در پایتون می‌توانند برای کپسوله‌سازی عملکردهای خاص و سازمان‌دهی، خوانایی و استفاده مجدد کد مورد استفاده قرار گیرند. مثال اول مساحت یک دایره را محاسبه می‌کند، در حالی که مثال دوم بررسی می‌کند که آیا عدد داده شده اول است یا خیر.

فراخوانی یک تابع در پایتون

پس از تعریف یک تابع در پایتون، می‌توانیم آن را با استفاده از نام تابع و به دنبال پرانتز (درصورتی‌که تابع هیچ پارامتری دریافت نمی‌کند) برای اجرای کد داخل تابع فراخوانی کنیم. توضیح و مثال برای فراخوانی تابع در پایتون در اینجا آمده است:

١. تعریف تابع:

def greet():‎

 print("Welcome to Makhtabkhooneh")

در کد بالا تابعی به نام greet()‎ تعریف کرده‌ایم که هیچ پارامتری را نمی‌گیرد. این شامل یک خط کد است که هنگام فراخوانی تابع، پیام Welcome to Makhtabkhooneh را چاپ می‌کند.

٢. فراخوانی تابع:

greet() # Calling the greet function‎

در این مثال، تابع greet() را با نوشتن greet() فراخوانی می‌کنیم. هنگامی که تابع فراخوانی می‌شود، کد داخل بدنه تابع اجرا شده و خروجی به‌صورت زیر خواهد بود:

Welcome to Makhtabkhooneh

فراخوانی یک تابع به سادگی استفاده از نام آن به دنبال پرانتز است. اگر تابع هر پارامتری را دریافت کند، باید در داخل پرانتز ارائه شود. برای توابع با دستور بازگشت، از فراخوانی تابع نیز می‌توان برای بازیابی مقدار بازگشتی توسط تابع استفاده کرد.

پارامترهای تابع در پایتون

در کار با توابع در پایتون، می‌توان توابع را با پارامترها تعریف و انواع داده‌ها و انواع برگشتی آن‌ها را مشخص کرد (برای پایتون 3.5 و بالاتر). در اینجا سینتکس برای تعریف و فراخوانی تابع با پارامترها آمده است:

def function_name(parameter: data_type) -> return_type:‎

 """Docstring"""

 return expression

حال بیایید این مفهوم را با یک مثال درک کنیم:

def add(num1: int, num2: int) -> int:‎

 """Add two numbers"""

 num3 = num1 + num2

 return num3

num1, num2 = 5, 15

ans = add(num1, num2)

print(f"The addition of {num1} and {num2} results {ans}.")

در این مثال، تابعی به نام add تعریف می‌کنیم که دو پارامتر عدد صحیح num1 و num2 را می‌گیرد. تابع add مجموع آن‌ها را محاسبه کرده و آن را در متغیر num3 ذخیره می‌کند که سپس به‌عنوان یک عدد صحیح برگردانده می‌شود. فراخوانی تابع add(num1,num2) مقادیر 5 و 15 را به‌عنوان آرگومان به تابع ارسال می‌کند و نتیجه برگردانده شده در متغیر ans ذخیره می‌شود. خروجی برنامه به‌صورت زیر خواهد بود:

The addition of 5 and 15 results in 20.‎

در این حالت، نوع بازگشتی تابع به‌صورت int مشخص می‌شود (که نشان می‌دهد یک عدد صحیح برمی‌گرداند) و پارامترهای num1 و num2 هر دو از نوع int هستند.

علاوه بر این، ما تابع دیگری به نام is_prime داریم تا بررسی کنیم که آیا یک عدد اول است یا خیر. این تابع یک پارامتر n را می‌گیرد و یک مقدار بولی (درست یا نادرست) برمی‌گرداند تا نشان دهد که عدد اول است یا خیر. خروجی فراخوانی is_prime(78) و is_prime(79) به‌صورت زیر خواهد بود:

False

True

این نشان می‌دهد که چگونه توابع را با پارامترها و انواع بازگشت در پایتون تعریف کنیم. با ارائه انواع داده‌های صریح برای پارامترها و مقادیر بازگشتی، می‌توانیم خوانایی کد را افزایش دهیم و ایمنی نوع بهتری را در برنامه‌های خود حفظ کنیم که این مسئله در کار با توابع در پایتون بسیار اهمیت دارد.

آرگومان‌های تابع در پایتون

در کار با توابع در پایتون، توابع می‌توانند انواع مختلفی از آرگومان‌ها را بر اساس نیاز خود بپذیرند. انواع مختلفی از آرگومان‌های تابع وجود دارد که در ادامه این مطلب از مجله مکتوب به آن‌ها می‌پردازیم.

آرگومان‌های موضعی

آرگومان‌های موضعی رایج‌ترین نوع آرگومان‌ها در کار با توابع در پایتون هستند. آن‌ها به ترتیبی که پارامترها در امضای تابع تعریف‌شده‌اند به یک تابع ارسال می‌شوند. مثال زیر برای درک این موضوع مهم است:

def nameAge(name, age):‎

 print("Hi, I am", name)

 print("My age is", age)

nameAge("Kamel", 29)

آرگومان‌های پیش‌فرض

آرگومان‌های پیش‌فرض در کار با توابع در پایتون دارای مقادیر پیش‌فرضی هستند که در تعریف تابع به آن‌ها اختصاص داده شده است. اگر در طول فراخوانی تابع، مقداری برای آرگومان پیش‌فرض ارائه نشود، از مقدار پیش‌فرض استفاده می‌شود. مثال زیر هم برای درک این موضوع مهم است:

def myFun(x, y=50):‎

 print("x:", x)

 print("y:", y)

myFun(10)

آرگومان‌های کلیدواژه

آرگومان‌های کلیدواژه با استفاده از نام پارامترها به دنبال مقادیر مربوطه به یک تابع ارسال می‌شوند. به‌این‌ترتیب، ترتیب آرگومان‌ها مهم نیست. مثال:

def student(firstname, lastname):‎

 print(firstname, lastname)

student(firstname=Kamel, lastname=Bahrami)

student(lastname=Bahrami, firstname=Kamel)

آرگومان‌های موضعی دلخواه (args)

آرگومان‌های موقعیتی یا همان موضعی دلخواه که به‌صورت *args‎ مشخص می‌شوند، به یک تابع اجازه می‌دهند تا تعداد متغیری از آرگومان‌های غیرکلیدی را بپذیرد. آرگومان‌ها به‌صورت یک تاپل به تابع ارسال می‌شوند و تابع می‌تواند آن‌ها را بر این اساس مدیریت کند؛ مانند مثال زیر:

def myFun(*argv):‎

 for arg in argv:‎

 print(arg)

myFun('Hello', 'Welcome', 'to', Maktabkhooneh)

آرگومان‌های کلیدواژه دلخواه

آرگومان‌های کلیدواژه دلخواه که به‌عنوان **kwargs‎ مشخص می‌شوند، به یک تابع اجازه می‌دهند تعداد متغیری از آرگومان‌های کلمه کلیدی را بپذیرد. آرگومان‌ها به‌عنوان نوعی دیکشنری به تابع منتقل می‌شوند و می‌تواند در صورت نیاز آن‌ها را پردازش کند. مثال:

def myFun(**kwargs):‎

 for key, value in kwargs.items():‎

 print("%s == %s" % (key, value))

myFun(first=Welcome, mid='to', last=Maktabkhooneh)

این انواع مختلف آرگومان‌های در کار با توابع در پایتون، انعطاف‌پذیری را در طراحی تابع فراهم کرده و توابع پایتون را همه‌کاره‌تر و کاربرپسندتر می‌کنند.

Docstring در کار با توابع در پایتون

رشته docstring یک رشته تحت‌اللفظی است که به‌عنوان اولین دستور در یک تابع قرار می‌گیرد. به‌عنوان مستنداتی برای کار با توابع در پایتون عمل می‌کند و جزئیات مربوط به هدف، ورودی‌ها، خروجی‌ها و هر اطلاعات مرتبط دیگری را ارائه می‌دهد. استفاده از docstrings یک روش خوب است زیرا به توسعه‌دهندگان دیگر (از جمله خود کاربر در آینده) کمک می‌کند تا رفتار تابع را بدون بررسی کد آن درک کنند.

برای دسترسی به رشته docstring یک تابع، می‌توانید از syntax function_name.__doc__ استفاده کنید که در آن function_name نام تابعی است که می‌خواهید رشته doc را برای آن بازیابی کنید. در اینجا یک مثال از یک تابع با یک رشته مستند آورده شده است:

def evenOdd(x):‎

 """Function to check if the number is even or odd"""

 if x % 2 == 0:‎

 print("even")

 else:‎

 print("odd")

print(evenOdd.__doc__)

هنگامی که کد بالا را اجرا می‌کنید، خروجی آن به شرح زیر خواهد بود:

Function to check if the number is even or odd

در این مثال، رشته docstring بلافاصله پس از تعریف تابع به‌عنوان یک رشته قرار می‌گیرد. عملکرد تابع را توصیف می‌کند، یعنی بررسی زوج یا فرد بودن عدد. به یاد داشته باشید که استفاده از docstring در کار با توابع در پایتون اختیاری است، اما توصیه می‌شود که آن‌ها را در توابع خود بگنجانید، مخصوصاً برای توابعی که بخشی از یک پایگاه کد بزرگ‌تر هستند یا قرار است توسط توسعه‌دهندگان دیگر استفاده شوند.

توابع تودرتو در پایتون

در کار با توابع در پایتون، تابعی که در داخل تابع دیگری تعریف می‌شود، تابع درونی یا تابع تودرتو نامیده می‌شود. توابع تودرتو به متغیرهای موجود در محدوده (خارجی) دسترسی دارند و می‌توانند از آن متغیرها حتی پس از اتمام اجرای تابع بیرونی استفاده کنند. این به‌عنوان محدوده واژگانی یا بسته شدن شناخته می‌شود. در اینجا یک مثال برای نشان دادن نحوه دسترسی توابع داخلی به متغیرها از محدوده محصور آورده شده است:

def f1():‎

 s = 'I love Maktabkhooneh'‎

 def f2():‎

 print(s)

 f2()‎

f1()‎

هنگامی که کد بالا را اجرا می‌کنید، خروجی آن به شرح زیر خواهد بود:

I love Maktabkhooneh

در این مثال، تابع f1()‎ حاوی یک تابع درونی f2()‎. در داخل f2()‎، قادر به دسترسی به متغیر s از محدوده محصور f1() است. تابع داخلی f2()‎ مقدار s را چاپ می‌کند که عبارت است از "I love Maktabkhooneh ". این توانایی توابع داخلی برای دسترسی به متغیرها از محدوده تابع بیرونی برای ایجاد بسته‌ها در پایتون مفید است. بسته شدن یک شی تابع است که مقادیر را در محدوده محصور به خاطر می‌آورد حتی اگر در حافظه وجود نداشته باشند.

توابع تودرتو را می‌توان برای محصور کردن توابعی خاص در محدوده عملکرد بیرونی مورد استفاده قرارداد و راهی برای محافظت از آن‌ها در برابر دسترسی یا اصلاح خارج از تابع فراهم می‌کند. همچنین توابع تودرتو در کار با توابع در پایتون به سازمان‌دهی کد و بهبود خوانایی با نگه‌داشتن قابلیت‌های مرتبط با هم کمک می‌کند.

توابع ناشناس در پایتون

در پایتون، یک تابع ناشناس که یکی از انواع توابع بوده و به‌عنوان تابع لامبدا نیز شناخته می‌شود، یک تابع بدون نام است. در حالی که توابع اصلی و معمولی با استفاده از کلمه کلیدی def تعریف می‌شوند، توابع لامبدا با استفاده از کلمه کلیدی lambda ایجاد خواهند شد. لامبدا از توابع مهم پایتون محسوب می‌شود و سینتکس استفاده از توابع لامبدا یا ناشناس در پایتون به‌صورت زیر است.

lambda arguments: expression‎

در اینجا مثالی از تابع لامبدا برای محاسبه مکعب یک عدد آورده شده است:

def cube(x): return x*x*x‎

cube_v2 = lambda x: x*x*x

print(cube(7))

print(cube_v2(7))

خروجی به‌صورت زیر است:

343

343

در این مثال، ما یک تابع معمولی cube(x) را با استفاده از کلمه کلیدی def تعریف کرده‌ایم که یک آرگومان x را می‌گیرد و مکعب آن را برمی‌گرداند. ما همچنین یک تابع lambda معادل cube_v2 ایجاد کردیم که همان عملیات را انجام می‌دهد. تابع لامبدا آرگومان x را می‌گیرد و x*x*x را برمی‌گرداند. توابع لامبدا اغلب زمانی استفاده می‌شوند که یک تابع کوچک و ناشناس برای مدت کوتاهی موردنیاز باشد و نیازی به نام رسمی برای آن نیست. آن‌ها معمولاً در موقعیت‌هایی استفاده می‌شوند که یک تابع به‌عنوان آرگومان برای توابع مرتبه بالاتر مانند map()، filter() و reduce() موردنیاز است.

توجه داشته باشید که در کار با توابع در پایتون، توابع لامبدا در مقایسه با توابع معمولی که با def تعریف‌شده‌اند، در قابلیت‌های خود محدود هستند. آن‌ها برای عملیات ساده و مختصر طراحی شده‌اند و نباید برای کارهای پیچیده یا توابع با چندین خط کد استفاده شوند. برای عملیات پیچیده‌تر، بهتر است یک تابع منظم با استفاده از def تعریف کنید.

دستور بازگشت در تابع پایتون

در پایتون، دستور return یا بازگشت برای خروج از یک تابع و برگرداندن یک مقدار یا آیتم داده خاص به فراخوان دهنده تابع استفاده می‌شود. سینتکس دستور بازگشت در کار با توابع در پایتون به‌صورت زیر است:

return [expression_list]

دستور return می‌تواند شامل یک متغیر، یک عبارت یا یک ثابت باشد که هنگام فراخوانی تابع، به‌عنوان نتیجه تابع برگردانده می‌شود. اگر عبارت return شامل هیچ مقداری نباشد، به‌طور پیش‌فرض None را برمی‌گرداند. در اینجا مثالی برای نشان دادن استفاده از عبارت return در یک تابع پایتون آورده شده است:

def square_value(num):‎

 """This function returns the square‎

 value of the entered number"""

 return num**2

print(square_value(2))

print(square_value(-4))

خروجی به‌صورت زیر است:

4

16

در این مثال، یک تابع square_value(num) تعریف می‌کنیم که یک عدد num را به‌عنوان ورودی می‌گیرد و مقدار مربع آن را با استفاده از عبارت return (num**2) برمی‌گرداند. وقتی تابع را با آرگومان‌های مختلف (2 و -4) فراخوانی می‌کنیم، مقدار مربع اعداد مربوطه را برمی‌گرداند.

استفاده از عبارت return به توابع اجازه می‌دهد تا نتایجی را ارائه دهند که می‌تواند در محاسبات یا انتساب‌های بعدی در برنامه استفاده شود. همچنین امکان استفاده مجدد از توابع را فراهم می‌کند، زیرا مقادیر بازگردانده شده توسط توابع می‌توانند در بخش‌های مختلف پایگاه کد مورد استفاده قرار گیرند.

ارسال به مرجع و ارسال به مقدار در کار با توابع پایتون

در کار با توابع در پایتون مفاهیم ارسال از مرجع و ارسال از مقدار دو مفهوم بسیار اساسی و مهم هستند که در ادامه این دو مفهوم به‌صورت کامل شرح داده خواهند شد.

ارسال از مرجع

در پایتون، وقتی یک شی (مثلاً یک لیست یا دیکشنری) را به‌عنوان آرگومان به یک تابع ارسال می‌کنید، یک مرجع جدید به همان شی در داخل تابع ایجاد می‌شود. هر تغییری که در شیء داخل تابع ایجاد شود، خارج از تابع نیز منعکس خواهد شد. این به این دلیل است که هم مرجع اصلی و هم پارامتر تابع به یک شی در حافظه اشاره دارند. مثال زیر این مفهوم را بیان می‌کند:

def myFun(x):‎

 x[0] = 20‎

lst = [10, 11, 12, 13, 14, 15]

myFun(lst)

print(lst)

خروجی به‌صورت زیر است:

[20, 11, 12, 13, 14, 15]

در مثال بالا لیست lst را به تابع myFun منتقل کردیم و تابع با تغییر اولین عنصر خود به 20 لیست را تغییر داد. در نتیجه تغییرات در لیست اصلی lst نیز قابل مشاهده است.

ارسال از مقدار

هنگامی که متغیری از انواع داده‌های تغییرناپذیر (مانند اعداد صحیح، رشته‌ها، تاپل‌ها) را به یک تابع ارسال می‌کنیم، یک مرجع جدید در داخل تابع ایجاد می‌شود، اما هر تغییری که در پارامتر دریافتی در داخل تابع ایجاد شود، بر متغیر اصلی تأثیر نمی‌گذارد. این به این دلیل است که اشیاء تغییرناپذیر توسط مقدار کپی می‌شوند و متغیر اصلی بدون تغییر باقی می‌ماند. مثال زیر این موضوع را نشان می‌دهد:

def myFun(x):‎

 x = 20

x = 10

myFun(x)

print(x)

خروجی به‌صورت زیر است:

10

در این مثال، یک عدد صحیح x به تابع myFun ارسال کردیم و تابع مقدار جدید 20 را به پارامتر x دریافت کرد. با این حال، این تغییر بر متغیر اصلی x تأثیر نمی‌گذارد، زیرا اعداد صحیح تغییرناپذیر هستند. در تمرین داده شده، ازآنجایی‌که اعداد صحیح تغییرناپذیر هستند، تابع مبادله نمی‌تواند مقادیر x و y را خارج از تابع تغییر دهد؛ بنابراین خروجی این خواهد بود:

2

3

اهمیت کار با توابع در پایتون

توابع در پایتون بلوک‌هایی از کد قابل‌استفاده مجدد هستند که با استفاده از کلمه کلیدی «def» تعریف‌شده‌اند. آن‌ها می‌توانند پارامترهای ورودی را بگیرند، داده‌ها را پردازش کرده و از عبارت «بازگشت یا Return» برای ارسال نتایج به تماس‌گیرنده استفاده کنند. توابع سازمان‌دهی کد، خوانایی و قابلیت استفاده مجدد را بهبود می‌بخشد و شیوه‌های برنامه‌نویسی کارآمد و مدولار را ترویج می‌کند. به امید اینکه مقاله فوق در رابطه با آموزش کار با توابع در پایتون مورد پسند کاربران عزیز مجله مکتب خونه قرار گرفته باشد.