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

توابع تعریف شده توسط کاربر

ساختار کلی توابع به صورت زیر است:

def func_name( parameters_optional ):
    """
    function docstring
    """
    statement(s)
    return[expression]

فراخوانی یک تابع در پایتون شبیه به زبان های برنامه نویسی دیگر است، با استفاده از نام تابع، پرانتز () و پارامتر (ها):

func_name( parameters )

اکثر مواقع، تعدادی آرگومان را به یک تابع می‌دهیم و تابع مقداری را بعنوان خروجی برمی‌گرداند. با اینحال ممکن است همیشه به این شکل نباشد. در بعضی موارد خواهیم داشت:

• تابعی که نه ورودی و نه خروجی دارد.
• تابعی که هیچ ورودی ندارد اما خروجی دارد
• تابعی که ورودی دارد اما هیچ خروجی ندارد.
• تابعی که هم ورودی و هم خروجی دارد.

تابعی که نه ورودی و نه خروجی دارد. تنها یک پیغام را چاپ می‌کند:

def say_hello():
    for i in range(0,3):
        print("hello!")

say_hello()

"""
output:
    hello!
    hello!
    hello!
"""

تابعی که هیچ ورودی ندارد اما خروجی دارد:

import random

def random_number():
    my_number = random.randint(1, 100)
    return my_number

var1 = random_number()
print("the random number is equal to", var1)

# output: the random number is equal to 67

به کمک کتابخانه‌ی random، با هر بار فراخوانی این تابع یک عدد صحیح تصادفی بین 1 و 100 را بر می‌گرداند. توجه داشته باشید که این تابع هیچ ورودی دریافت نمی‌کند.

تابعی که ورودی دارد اما هیچ خروجی ندارد:

def even_or_odd(var1):
    if var1 % 2 == 0:
        print(var1, "is an even number")
    else:
        print(var1, "is an odd number")

even_or_odd(-67)

# output: -67 is an odd number

تابعی که هم ورودی و هم خروجی دارد:

def multiple_arguments(val1, val2, val3, calcSum = True):
    # Calculate the sum
    if calcSum:
        return val1 + val2 + val3
    # Calculate the average instead
    else:
        return (val1 + val2 + val3) / 3

var1 = multiple_arguments(-5, 7.9, 10)
var2 = multiple_arguments(-5, 7.9, 10, False)
print("var1 should be the sum of (-5, 7.9, 10): ", var1)
print("var2 should be the average of (-5, 7.9, 10):", var2)

"""
output:
    var1 should be the sum of (-5, 7.9, 10):  12.9
    var2 should be the average of (-5, 7.9, 10): 4.3    
""”

شما می‌توانید تابع را از نظر آرگومان‌های ورودی به شکل‌های زیر فراخوانی کنید:

• آرگومان های اجباری: آرگومان های اجباری آن های هستند که در مکان و ترتیب قرارگیری درست خود به تابع ارسال می‌شوند و در غیر اینصورت خطای syntaxایجاد خواهد شد.
• آرگومان های keyword: هنگامی که از آرگومان‌های keyword در فراخوانی تابع استفاده می‌شود، فراخواننده آرگومان‌ها را به وسیله‌ی اسم آن (پارامتر) شناسایی می‌کند. با این روش ترتیب پارامترها اهمیتی ندارد و می‌توان ترتیب آنها را تغییر داد، زیرا مفسر پایتون قادر است با استفاده از کلید واژه، مقادیر را به پارامترها مرتبط سازد. به عبارتی در هنگام فراخوانی علاوه بر مقدار مورد نظر برای آرگومان، نام آرگومان هم قبل از علامت (=) می‌آید.
• آرگومان های پیشفرض: در صورتیکه هیچ مقداری به آرگومان فراخوانی شده اختصاص داده نشود، آرگومان پیشفرض مقدار آن را مشخص می‌کند.
• آرگومان های variable-length: گاهی لازم است یک تابع را با آرگومان‌های بیشتری نسبت به آنچه در زمان تعریف تابع مشخص کردید، پردازش و فراخوانی کنید. این دست از آرگومان‌ها در اصطلاح آرگومان‌های با طول متغیر (variable_length) خوانده می‌شوند و برخلاف آرگومان‌های الزامی و پیش فرض، در تعریف تابع ذکر نمی‌شوند.

توابع داخلی پایتون

توابع داخلی (Built-in Functions)، بخشی از کتابخانه استاندارد پایتون می‌باشند. در این مقاله به تعدادی از این توابع اشاره خواهیم کرد. این توابع در انجام عملیات‌های مختلف به کمک شما می‌آیند. دلیل اینکه به این توابع، توابع داخلی می‌گویند اینست که به صورت پیش فرض، در داخل زبان برنامه نویسی پایتون وجود دارند. برای آشنایی با تمام توابع داخلی به مستندات پایتون مراجعه کنید.

()Abs

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

var1 = -11.55
var2 = 10
print (abs(var1))
print (abs(var2))

"""
output:
    11.55
    10
"""

()bin

تابع bin عدد صحیح را به یک رشته‌ی باینری تبدیل می‌کند با پیشوند “0b” . توجه داشته باشید که این تابع عدد اعشاری را به باینری تبدیل نمی‌کند:

var1 = bin(4)
var2 = bin(-10)

print("convert 4 to binary:", var1)
print("convert -10 to binary:", var2)

"""
output:
    convert 4 to binary: 0b100
    convert -10 to binary: -0b1010
"""

()chr

این تابع با گرفتن یک آرگومان ورودی کاراکتری که برای آن عدد صحیح مشخص شده است را نشان می‌دهد:

var1 = chr(97)
var2 = chr(547)

print("chr(97) returns the string:", var1)
print("chr(547) returns the string:", var2)

"""
output:
    chr(97) returns the string: a
    chr(8647) returns the string: ȣ
"""

()enumerate

علاوه‌ بر تابع ()range در حلقه‌های for می‌توانیم از این تابع نیز استفاده کنیم. این تابع یک شی دنباله یا تکرارکننده را به عنوان آرگومان ورودی دریافت می‌کند و یک شی از نوع enumerate  برمی‌گرداند:

my_list = ["python", "java", "c#" ]
enum = enumerate(my_list)
print("type:", type(enum))
print("convert the object to a list:", list(enum))

"""
output:
    type: <class 'enumerate'>
    convert the object to a list: [(0, 'python'), (1, 'java'), (2, 'c#')]
"""

با تبدیل این شی به یک شی لیست مشاهده می‌شود که این شی عضوهای آرگومان ورودی خود را به شکل جفت‌هایی به همراه اندیس موقعیت آن‌ها ذخیره کرده است.

این تابع همچنین یک آرگومان اختیاری با نام start  دارد که با مقدار دادن به آن می‌توان عدد ابتدایی شمارش اندیس‌ها را تعیین نمود؛ مقدار پیش‌فرض این آرگومان عدد صفر است.

()eval

این تابع در پایتون یک شی رشته را دریافت و متن آن را به شکل کد پایتون تفسیر می‌کند:

var1 = 1
var2 = eval('var1+3')
print("eval() evaluates the expression x + 3: ", var2)
print("type of this value is:", type(var2))

"""
output:
    eval() evaluates the expression x + 3:  4
    type of this value is: <class 'int'>
"""

برای درک بهتر کاربرد تابع eval به مثال زیر توجه کنید:

def function_1(var1):
    return var1*3
def function_2(var1):
    return var1+4

user_input = input("type name of a function: ")

for var1 in range(2,4):
    if( user_input == 'function_1(var1)' ):
        print("if var1 is ", var1, "the result is equal to:", eval(user_input))
    elif( user_input == 'function_2(var1)' ):
        print("if var1 is ", var1, "the result is equal to:", eval(user_input))
    else:
        print('Wrong Function')
        break

"""
output:
    type name of a function: function_2(var1)
    if var1 is  2 the result is equal to: 6
    if var1 is  3 the result is equal to: 7
"""
"""
output:
    type name of a function: function_3(var1)
    Wrong Function
"""

()float

این تابع ورودی را تبدیل به نوع float می‌کند:

print(float("13.6"))
print(float(13))
print(float(6.791e5))

"""
output:
    13.6
    13.0
    679100.0
"""

()input

تابع input یک سطر از کاربر را می‌خواند و در قالب یک شی از نوع str برمی‌گرداند:

var1 = input("--> ")
print(var1)
print(type(var1))

"""
output:
    --> hello world
    hello world
    <class 'str'>
"""

با اجرا دستور سطر یکم، مفسر پایتون منتظر ورود متن می‌ماند. در این نمونه متن (hello world ) نوشته می‌شود سپس با دریافت کلید enter  تمام کاراکتر‌های دریافتی را در قالب یک شی در نوع str به متغیر var1 ارجاع می‌دهد.

()int

از این تابع برای تبدیل یک مقدار به نوع int استفاده می‌شود. ساختار کلی این دستور به صورت زیر است که x می‌تواند هر مقداری که قابل تبدیل به int است باشد:

print(int("13"))
print(int(13.09))
print(int(6.791e3))

"""
output:
    13
    13
    6791
"""

()len

این تابع، طول یک شیء را برمی‌گرداند. آرگومان ممکن است یک توالی (مانند یک رشته، بایت یا لیست) یا یک مجموعه، مانند یک  دیکشنری باشد:

my_list = ["float", "len", "eval", 1, 2]
print("the length of my list is:", len(my_list))

# output: the length of my list is: 5

(map(function, iterable

تابع map یک تابع  و یک لیست را در ورودی خود میگیرد و تک تک المان های آن لیست را به تابع ارسال می‌کند و خروجی آن تابع را در یک لیست جدید قرار می‌دهد:

def calculateSquare(var1):
  return var1*var1

side_size = (1, 2, 3, 4)
result = map(calculateSquare, side_size)
print(result)

#converting map object to list
print(list(result))

"""
output:
    <map object at 0x029935D0>
    [1, 4, 9, 16]
"""

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

def myfunc(var1, var2):
  return var1 + var2

name = map(myfunc, ('ze', 't', 'he'), ('ro', 'o', 'ro'))
print(name)

#convert map object to list,for readability:
print(list(name))

"""
output:
  <map object at 0x03B3D7F0>
  ['zero', 'to', 'hero']
"""

()max

این تابع، بزرگترین آیتم را در یک دنباله و یا بزرگترین آیتم  بین دو یا چند آرگومان وارد شده را برمی‌گرداند.

()min

این تابع ،کوچکترین آیتم را در یک دنباله و یا کوچکترین آیتم بین دو یا چند آرگومان وارد شده را برمی‌گرداند:

my_list = [-15,-2,18,7,-10,32,0]
print("the largest item of my list is:", max(my_list))
print("the smallest item of my list is:", min(my_list))
print("max of the first item and the last:", max(my_list[0],my_list[-1]))
print("min of the first item and the last:", min(my_list[0],my_list[-1]))

"""
output:
    the largest item of my list is: 32
    the smallest item of my list is: -15
    max of the first item and the last: 0
    min of the first item and the last: -15
"""

()reversed

این تابع معکوس یک دنباله را برمی‌گرداند:

# for string
seqString = 'Python'
print(list(reversed(seqString)))

# for tuple
seqTuple = ('P', 'y', 't', 'h', 'o', 'n')
print(list(reversed(seqTuple)))

# for range
seqRange = range(5, 9)
print(list(reversed(seqRange)))

# for list
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))

"""
output:
    ['n', 'o', 'h', 't', 'y', 'P']
    ['n', 'o', 'h', 't', 'y', 'P']
    [8, 7, 6, 5]
    [5, 3, 4, 2, 1]
"""

()sorted

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

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

Reverse: یک مقدار Boolean است. اگر برابر True باشد، عناصر لیست به صورت معکوس مرتب می‌شوند:

my_list = [[2,1], [6, 3], [11, 14], [-14, 12], [10, 13]]

def my_key(item):
    return item[0]
new_sorted_list = sorted(my_list, key=my_key)
print("The sorted list looks like:", new_sorted_list)

# output: The sorted list looks like: [[-14, 12], [2, 1], [6, 3], [10, 13], [11, 14]]

در مثال بالا لیست را با توجه به آیتم های اول مرتب کرده است.

()str

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

my_num = 13
my_string = "80"
print(my_string + str(my_num))

# output: 8013

()tuple

بوسیله این تابع می‌توان یک رشته، یک لیست یا یک set از آیتم های مختلف را به یک tuple  تبدیل کرد:

print(tuple({'physics', 'chemistry', 1997, 2000}))
print(tuple({1, 5, 8, 3, 6, 2, 4, 7}))
print( tuple("2,3,4,5"))

"""
output:
    (2000, 'chemistry', 'physics', 1997)
    (1, 2, 3, 4, 5, 6, 7, 8)
    ('2', ',', '3', ',', '4', ',', '5')
"""

()list

دقیقاً مشابه tuple عمل کرده، اما خروجی آن یک list است:

()type

اگر یک آرگومان به type پاس داده شود، نوع شیء داده شده را باز می‌گرداند:

numberList = [1, 2, 3, 4]
print(type(numberList))

numberDict = {"key_1": 'one', "key_2": 'two'}
print(type(numberDict))

"""
output:
    <class 'list'>
    <class 'dict'>
"""

()zip

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

name = ["Rachel", "Ross", "Monica", "chandler"]
grade = [17, 19, 16]
zipped = zip(name, grade)
print(list(zipped))

# output: [('Rachel', 17), ('Ross', 19), ('Monica', 16)]

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

name = ["Rachel", "Ross", "Monica"]
age = [23, 24, 25]
grade = [17, 19, 16]

for x in zip(name, age, grade):
    print(x)
    
"""
output:
    ('Rachel', 23, 17)
    ('Ross', 24, 19)
    ('Monica', 25, 16)
"""

از اپراتور * برای unzip کردن لیست می‌توان استفاده کرد برای مثال:

my_list = [[1, 2, 3, 4],
           [5, 6, 7, 8],
           [9, 10, 11, 12]]

for i in zip(*my_list):
    print(i)
    
"""
output:
    (1, 5, 9)
    (2, 6, 10)
    (3, 7, 11)
    (4, 8, 12)
"""

جمع‌بندی

در این مقاله با کاربرد توابع و انواع آن آشنا شدیم. برای آشنایی با مفهوم تابع در برنامه‌نویسی به این لینک مراجعه کنید.