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

Default Arguments

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

Required Arguments

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

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

Keyword Arguments

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

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

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

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

เครื่องหมายดอกจัน (*) วางไว้หน้าชื่อตัวแปรที่เก็บค่าของอาร์กิวเมนต์แบบไม่ใช่คีย์เวิร์ดทั้งหมด สังเกตว่าสามารถใช้ชื่ออื่นแทน *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

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

def double(x):
  return x*2

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

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

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

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

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

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

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

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