ฟังก์ชันใน Python: วิธีเรียกใช้และเขียนฟังก์ชัน

Default Arguments

อาร์กิวเมนต์ค่าเริ่มต้นคืออาร์กิวเมนต์ที่รับค่าเริ่มต้นหากไม่มีการส่งค่าเข้ามาระหว่างการเรียกใช้ฟังก์ชัน สามารถกำหนดค่าเริ่มต้นนี้ได้ด้วยโอเปอเรเตอร์กำหนดค่า = ดังตัวอย่างต่อไปนี้:

# Define `plus()` function
def plus(a,b = 2):
  return a + b
  
# Call `plus()` with only `a` parameter
plus(a=1)

# Call `plus()` with `a` and `b` parameters
plus(a=1, b=3)

Required Arguments

ตามชื่อ อาร์กิวเมนต์ที่จำเป็นของ UDF คือสิ่งที่ต้องมี อาร์กิวเมนต์เหล่านี้ต้องถูกส่งเข้ามาระหว่างการเรียกใช้ฟังก์ชันและต้องอยู่ในลำดับที่ถูกต้อง ดังตัวอย่างต่อไปนี้:

# Define `plus()` with required arguments
def plus(a,b):
  return a + b

จำเป็นต้องมีอาร์กิวเมนต์ที่แมปกับพารามิเตอร์ a และ b เพื่อเรียกใช้ฟังก์ชันโดยไม่เกิดข้อผิดพลาด หากสลับ a และ b ผลลัพธ์จะไม่ต่างกัน แต่จะต่างกันได้หากเปลี่ยน plus() เป็นแบบต่อไปนี้:

# Define `plus()` with required arguments
def plus(a,b):
  return a/b

Keyword Arguments

หากต้องการให้แน่ใจว่าเรียกพารามิเตอร์ถูกลำดับ สามารถใช้อาร์กิวเมนต์แบบคีย์เวิร์ดในการเรียกฟังก์ชัน ใช้วิธีนี้เพื่อระบุอาร์กิวเมนต์ด้วยชื่อพารามิเตอร์ มาดูตัวอย่างจากด้านบนเพื่อให้ชัดเจนขึ้น:

# Define `plus()` function
def plus(a,b):
  return a + b
  
# Call `plus()` function with parameters 
plus(2,3)

# Call `plus()` function with keyword arguments
plus(a=1, b=2)

สังเกตว่าเมื่อใช้อาร์กิวเมนต์แบบคีย์เวิร์ด สามารถสลับลำดับพารามิเตอร์และยังคงได้ผลลัพธ์เดียวกันเมื่อรันฟังก์ชัน:

# Define `plus()` function
def plus(a,b):
  return a + b
  
# Call `plus()` function with keyword arguments
plus(b=2, a=1)

จำนวนอาร์กิวเมนต์แปรผัน

ในกรณีที่ไม่ทราบจำนวนอาร์กิวเมนต์ที่ต้องการส่งให้ฟังก์ชันแน่ชัด สามารถใช้ไวยากรณ์ดังต่อไปนี้กับ *args ได้:

# Define `plus()` function to accept a variable number of arguments
def plus(*args):
  return sum(args)

# Calculate the sum
plus(1,4,5)

เครื่องหมายดอกจัน (*) วางไว้หน้าชื่อตัวแปรที่เก็บค่าของอาร์กิวเมนต์แบบไม่ใช่คีย์เวิร์ดทั้งหมด สังเกตว่าสามารถใช้ชื่ออื่นแทน *args เช่น *varint, *var_int_args หรือชื่อใด ๆ เมื่อส่งเข้าไปยังฟังก์ชัน plus() ก็ได้

เคล็ดลับ: ลองแทนที่ *args ด้วยชื่ออื่นที่มีดอกจัน จะเห็นว่าโค้ดด้านบนยังทำงานต่อไปได้!

จะเห็นว่าฟังก์ชันด้านบนใช้ฟังก์ชันที่มีมาให้ของ Python อย่าง sum() เพื่อบวกรวมอาร์กิวเมนต์ทั้งหมดที่ส่งเข้าไปยัง plus() 

ตัวแปรแบบ global กับแบบ local

โดยทั่วไป ตัวแปรที่กำหนดในเนื้อฟังก์ชันจะมีขอบเขตแบบ local ส่วนตัวแปรที่กำหนดไว้ภายนอกจะมีขอบเขตแบบ global นั่นหมายความว่า ตัวแปร local ถูกกำหนดภายในบล็อกของฟังก์ชันและเข้าถึงได้เฉพาะภายในฟังก์ชันนั้น ขณะที่ตัวแปร global สามารถเข้าถึงได้โดยฟังก์ชันทั้งหมดในสคริปต์ของคุณ:

จะเห็นว่าเกิด NameError ระบุว่า name 'total' is not defined เมื่อพยายามพิมพ์ตัวแปร local total ที่ถูกกำหนดภายในเนื้อฟังก์ชัน ด้านทางกลับกัน ตัวแปร init สามารถพิมพ์ได้โดยไม่มีปัญหา

พารามิเตอร์แบบ positional-only และ keyword-only

ตั้งแต่ Python 3.8 เป็นต้นมา สามารถควบคุมวิธีการส่งอาร์กิวเมนต์ได้มากขึ้นด้วยเครื่องหมายพิเศษสองตัวในลายเซ็นของฟังก์ชัน คือ / และ * สิ่งที่อยู่ก่อน / จะส่งได้เฉพาะแบบตำแหน่งเท่านั้น ส่วนที่อยู่หลัง * จะส่งได้เฉพาะแบบคีย์เวิร์ดเท่านั้น

def greet(name, /, greeting="Hello", *, punctuation="!"):
    print(f"{greeting} {name}{punctuation}")ขับเคลื่อนโดย

 ตัวอย่างการเรียกใช้จะเป็นดังนี้:

greet("Alice")                          # works
greet("Alice", greeting="Hi")           # works
greet("Alice", "Hi", punctuation="?")   # works

greet(name="Alice")                     # TypeError: name is positional-only
greet("Alice", "Hi", "?")               # TypeError: punctuation is keyword-onlyขับเคลื่อนโดย

ทำไมถึงอยากใช้แบบนี้? มีสองเหตุผลหลัก

หนึ่ง, พารามิเตอร์แบบ positional-only ช่วยให้เปลี่ยนชื่อในภายหลังได้โดยไม่ทำให้โค้ดของใครพัง เพราะไม่มีใครได้รับอนุญาตให้ใช้ชื่อนั้นเป็นคีย์เวิร์ด จึงเปลี่ยนชื่อได้อิสระ

สอง, พารามิเตอร์แบบ keyword-only บังคับให้ผู้เรียกใช้ระบุอย่างชัดเจนว่ากำลังส่งอะไร ทำให้การเรียกอ่านง่ายขึ้นเมื่อมีแฟลกหรือการตั้งค่าทางเลือกหลายตัว

สรุปคือ เป็นวิธีที่สะอาดในการบังคับใช้เจตนา

ฟังก์ชันนิรนามใน Python

ฟังก์ชันนิรนามใน Python เรียกว่าฟังก์ชันแลมบ์ดา เพราะแทนที่จะประกาศด้วยคีย์เวิร์ดมาตรฐาน def จะใช้คีย์เวิร์ด lambda

double = lambda x: x*2

double(5)

ในส่วน DataCamp Light ด้านบน lambda x: x*2 คือฟังก์ชันนิรนามหรือฟังก์ชันแลมบ์ดา x คืออาร์กิวเมนต์ และ x*2 คือ expression หรือคำสั่งที่ถูกประเมินและคืนค่า ความพิเศษของฟังก์ชันนี้คือไม่มีชื่อ แตกต่างจากตัวอย่างในส่วนแรกของบทช่วยสอนฟังก์ชัน หากต้องเขียนฟังก์ชันข้างต้นเป็น UDF จะได้ผลลัพธ์ดังนี้:

def double(x):
  return x*2ขับเคลื่อนโดย

พิจารณาตัวอย่างฟังก์ชันแลมบ์ดาที่ทำงานกับอาร์กิวเมนต์สองตัว:

# `sum()` lambda function
sum = lambda x, y: x + y;

# Call the `sum()` anonymous function
sum(4,5)

# "Translate" to a UDF
def sum(x, y):
  return x+y

มักใช้ฟังก์ชันนิรนามเมื่อจำเป็นต้องใช้ฟังก์ชันที่ไม่มีชื่อชั่วคราวและถูกสร้างขึ้นขณะรันไทม์ บริบทที่เกี่ยวข้องเช่นเมื่อทำงานกับ filter(), map() และ reduce():

from functools import reduce

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

# Use lambda function with `filter()`
filtered_list = list(filter(lambda x: (x*2 > 10), my_list))

# Use lambda function with `map()`
mapped_list = list(map(lambda x: x*2, my_list))

# Use lambda function with `reduce()`
reduced_list = reduce(lambda x, y: x+y, my_list)

print(filtered_list)
print(mapped_list)
print(reduced_list)

ฟังก์ชัน filter() จะกรองลิสต์อินพุตเดิม my_list ตามเงื่อนไข >10 ตามชื่อของมัน ส่วน map() จะนำฟังก์ชันไปใช้กับทุกองค์ประกอบของลิสต์ my_list ในที่นี้คือคูณทุกองค์ประกอบด้วย 2

สังเกตว่า reduce() อยู่ในไลบรารี functools ใช้ฟังก์ชันนี้แบบสะสมกับรายการในลิสต์ my_list จากซ้ายไปขวา และย่อลำดับให้เหลือค่าเดียว ซึ่งในที่นี้คือ 55

การใช้ main() เป็นฟังก์ชันใน Python

หากมีประสบการณ์กับภาษาอื่นอย่าง Java จะทราบว่าต้องมีฟังก์ชัน main เพื่อรันฟังก์ชันต่าง ๆ แต่จากตัวอย่างด้านบนจะเห็นว่า Python ไม่จำเป็นต้องมี อย่างไรก็ตาม การใส่ฟังก์ชัน main() ในโปรแกรม Python จะช่วยจัดโครงร่างโค้ดอย่างมีเหตุผล องค์ประกอบที่สำคัญที่สุดจะถูกรวมไว้ในฟังก์ชัน main() นี้

สามารถนิยามฟังก์ชัน main() และเรียกใช้ได้ง่าย ๆ เช่นเดียวกับฟังก์ชันอื่น ๆ ด้านบน:

# Define `main()` function
def main():
  hello()
  print("This is a main function")

main()

อย่างไรก็ตาม ในสภาพนี้ โค้ดของฟังก์ชัน main() จะถูกเรียกเมื่อมีการ import ไฟล์เป็นโมดูล เพื่อป้องกันไม่ให้เกิดขึ้น ควรเรียกฟังก์ชัน main() เมื่อ __name__ == '__main__'

ดังนั้นโค้ดในส่วนด้านบนจะกลายเป็นดังนี้:

# Define `main()` function
def main():
  hello()
  print("This is a main function")
  
# Execute `main()` function 
if __name__ == '__main__':
    main()

หมายเหตุ นอกเหนือจากฟังก์ชัน __main__ แล้ว ยังมีฟังก์ชัน __init__ ที่ใช้เริ่มต้นอินสแตนซ์ของคลาสหรืออ็อบเจ็กต์ กล่าวโดยย่อคือทำหน้าที่เป็นคอนสตรักเตอร์หรือตัวเริ่มต้น และถูกเรียกอัตโนมัติเมื่อสร้างอินสแตนซ์ของคลาสใหม่ ด้วยฟังก์ชันนี้ อ็อบเจ็กต์ที่สร้างใหม่จะถูกกำหนดให้กับพารามิเตอร์ self ซึ่งเห็นไปแล้วในบทช่วยสอนนี้ ดูตัวอย่างต่อไปนี้:

class Dog:
    """A simple Dog class.

    Args:
        legs: Number of legs so that the dog can walk.
        color: The color of the fur.
    """

    def __init__(self, legs: int, color: str) -> None:
        self.legs = legs
        self.color = color

    def bark(self) -> str:
        return "bark" * 2

if __name__ == "__main__":
    dog = Dog(4, "brown")
    print(dog.bark())ขับเคลื่อนโดย