ฟังก์ชันในภาษาไพธอน

บทความนี้อธิบายเกี่ยวกับฟังก์ชันในภาษาไพธอน

YouTube Video

ฟังก์ชันในภาษาไพธอน

ฟังก์ชันในภาษาไพธอนเป็นคุณสมบัติที่สำคัญสำหรับการกำหนดบล็อกโค้ดที่ใช้ซ้ำได้ ช่วยให้คุณสามารถจัดระเบียบและลดความซับซ้อนของโปรแกรมของคุณโดยการเรียกใช้ตามความต้องการ การใช้ฟังก์ชันสามารถช่วยปรับปรุงความสามารถในการอ่านโค้ด และเป็นไปตามหลักการ DRY (Don't Repeat Yourself, หลีกเลี่ยงการเขียนโค้ดซ้ำซ้อน)

การกำหนดฟังก์ชัน

ฟังก์ชันถูกกำหนดโดยการใช้คำสั่ง def ไวยากรณ์พื้นฐานมีดังนี้:

1def function_name(arg1, arg2, ..., argN):
2    """docstring (A brief description of the function)"""
3    processing
4    return return_value

ยกตัวอย่างเช่น เพื่อกำหนดฟังก์ชันที่บวกตัวเลขสองตัว คุณสามารถเขียนดังนี้:

1def add(x, y):
2    """A function that adds two numbers and returns the result"""
3    return x + y

การเรียกใช้งานฟังก์ชัน

ฟังก์ชันที่กำหนดไว้สามารถเรียกใช้งานได้ดังนี้:

1result = add(3, 4)
2print(result)  # Output: 7

ส่วนประกอบของฟังก์ชัน

1. ชื่อฟังก์ชัน

   • ชื่อของฟังก์ชันที่ใช้เมื่อต้องการเรียกใช้งาน

2. อาร์กิวเมนต์ (พารามิเตอร์)

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

3. สตริงเอกสาร (Docstring)

   • ข้อความที่ใช้บรรยายวัตถุประสงค์และวิธีการใช้งานของฟังก์ชัน ไม่บังคับ

4. เนื้อหาของฟังก์ชัน

   • บล็อกคำสั่งที่มีการเยื้อง ซึ่งใช้เขียนโค้ดที่จะถูกรันเมื่อเรียกฟังก์ชัน

5. ค่าที่ส่งกลับ

   • ค่าที่ถูกส่งกลับไปยังผู้เรียกโดยใช้คำสั่ง return หากไม่มีการใช้คำสั่ง return จะส่งกลับค่า None โดยค่าเริ่มต้น

ประเภทของอาร์กิวเมนต์

ในภาษาไพธอน มีอาร์กิวเมนต์หลายประเภท

1. อาร์กิวเมนต์ตามลำดับตำแหน่ง
   • วิธีปกติในการส่งอาร์กิวเมนต์เข้าไปในฟังก์ชัน
2. อาร์กิวเมนต์ค่าเริ่มต้น
   • กำหนดค่าเริ่มต้นให้อาร์กิวเมนต์เพื่อให้สามารถละเว้นได้ขณะเรียกฟังก์ชัน

1def greet(name, message="Hello"):
2    print(f"{message}, {name}")
3
4greet("Alice")  # "Hello, Alice"
5greet("Bob", "Good morning")  # "Good morning, Bob"

3. อาร์กิวเมนต์จำนวนไม่แน่นอน
   • args จะรับอาร์กิวเมนต์ตำแหน่งหลายตัวในรูปแบบทูเพิล และ kwargs จะรับในรูปแบบดิกชันนารี

1def func(*args, **kwargs):
2    print("args:", args)
3    print("kwargs:", kwargs)
4
5func(1, 2, 3, a=4, b=5)
6# Output:
7# args: (1, 2, 3)
8# kwargs: {'a': 4, 'b': 5}

การใช้งานฟังก์ชันอย่างถูกต้องจะช่วยให้คุณเขียนโปรแกรม Python ได้อย่างมีประสิทธิภาพและประสิทธิผลมากขึ้น

ฟังก์ชัน Lambda ใน Python

ใน Python ฟังก์ชัน lambda ใช้สำหรับกำหนดฟังก์ชันแบบไม่มีชื่อและกระชับ ต่างจากฟังก์ชันที่กำหนดด้วยคีย์เวิร์ด def ปกติ lambda ช่วยให้คุณสร้างฟังก์ชันสั้นที่มีเพียงบรรทัดเดียว ที่นี่เราจะอธิบายฟังก์ชัน lambda ใน Python อย่างละเอียด

พื้นฐานเกี่ยวกับฟังก์ชัน lambda

ฟังก์ชัน lambda หรือที่เรียกว่าฟังก์ชันไม่มีชื่อ ใช้เพื่อกำหนดฟังก์ชันชั่วคราวที่ไม่มีชื่อ ตามชื่อที่ระบุ ไวยากรณ์พื้นฐานมีดังนี้:

1lambda arguments: expression

• arguments
  • ระบุอาร์กิวเมนต์ของฟังก์ชัน สามารถระบุอาร์กิวเมนต์หลายตัวโดยใช้เครื่องหมายจุลภาคคั่น
• expression
  • นิพจน์ที่ถูกประเมินค่าตามอาร์กิวเมนต์ ผลลัพธ์ของนิพจน์จะกลายเป็นค่าที่ฟังก์ชันส่งกลับ

ตัวอย่างเช่น โค้ดต่อไปนี้กำหนดและเรียกใช้ฟังก์ชัน lambda ที่ใช้บวกเลขสองตัว

1add = lambda x, y: x + y
2print(add(5, 3))  # Output: 8

ในตัวอย่างนี้ lambda x, y: x + y เป็นฟังก์ชัน lambda ที่รับอาร์กิวเมนต์สองตัว x และ y และคืนผลรวมของมัน

กรณีการใช้งานฟังก์ชัน lambda

ฟังก์ชัน lambda มีประโยชน์ในสถานการณ์ที่คุณต้องการกำหนดฟังก์ชันง่ายๆ ทันที พวกมันมักใช้ในกรณีต่อไปนี้:

1. เมื่อส่งเป็นอาร์กิวเมนต์ให้กับฟังก์ชัน

   • มันมีประโยชน์ในฟังก์ชันลำดับสูง (ฟังก์ชันที่รับฟังก์ชันอื่นเป็นอาร์กิวเมนต์) เมื่อส่งผ่านฟังก์ชันสั้น ๆ ชั่วคราว

2. เมื่อกำหนดลำดับคีย์สำหรับการจัดเรียงลิสต์

   • ฟังก์ชันเหล่านี้มีประโยชน์สำหรับการกำหนดเกณฑ์การจัดเรียง (คีย์) ในฟังก์ชันเช่น sort() หรือ sorted()

ตัวอย่างการใช้งานในฟังก์ชันระดับสูง

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

1numbers = [1, 2, 3, 4, 5]
2squared = list(map(lambda x: x ** 2, numbers))
3print(squared)  # Output: [1, 4, 9, 16, 25]

ในตัวอย่างนี้ ฟังก์ชัน lambda ถูกส่งไปยังฟังก์ชัน map() เพื่อยกกำลังสองแต่ละตัวเลขในลิสต์

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

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

1pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
2pairs.sort(key=lambda pair: pair[1])
3print(pairs)
4# Output: [(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

ในตัวอย่างนี้ ฟังก์ชัน lambda ถูกใช้ในการจัดเรียง tuple ตามองค์ประกอบที่สอง (ซึ่งเป็นสตริง)

filter() และ lambda

ฟังก์ชัน filter() ใช้สำหรับกรององค์ประกอบในรายการ (หรือข้อมูล iterable อื่นๆ) โดยอ้างอิงตามเงื่อนไขที่กำหนด

1numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
2even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
3print(even_numbers)  # Output: [2, 4, 6, 8]

ในตัวอย่างนี้ ตัวเลขคู่ในรายการจะถูกกรองเพื่อสร้างรายการใหม่

lambda และ reduce()

ฟังก์ชัน reduce() ใช้สำหรับลดรายการให้เป็นค่าหนึ่งค่า สามารถนำไปใช้งานได้ง่ายด้วยการใช้ฟังก์ชัน lambda

1from functools import reduce
2
3numbers = [1, 2, 3, 4, 5]
4product = reduce(lambda x, y: x * y, numbers)
5print(product)  # Output: 120

ในตัวอย่างนี้ องค์ประกอบทั้งหมดในรายการจะถูกคูณเข้าด้วยกันเพื่อสร้างผลลัพธ์

หลีกเลี่ยงการใช้ฟังก์ชัน lambda ที่ซับซ้อน

ข้อได้เปรียบของฟังก์ชัน lambda คือความกระชับ แต่จะอ่านยากขึ้นเมื่อใช้งานเพื่อดำเนินตรรกะที่ซับซ้อน ดังนั้นจึงเหมาะที่จะใช้งานสำหรับการปฏิบัติการแบบง่ายที่สามารถเขียนได้ภายในบรรทัดเดียว สำหรับการปฏิบัติการที่ซับซ้อน การกำหนดฟังก์ชันด้วย def จะอ่านง่ายกว่าและดูแลรักษาได้ดีกว่า

ตัวอย่างเช่น คุณควรหลีกเลี่ยงการใช้ฟังก์ชัน lambda ที่ซับซ้อน เช่นตัวอย่างด้านล่าง

1# Complex and hard-to-read lambda function
2complex_func = lambda x, y: (x * 2 + y) if x > y else (x + y * 2)

ในกรณีนี้ ควรใช้งานฟังก์ชันที่กำหนดด้วย def ดังที่แสดงด้านล่าง

1def complex_func(x, y):
2    if x > y:
3        return x * 2 + y
4    else:
5        return x + y * 2

สรุป

ฟังก์ชัน lambda ใน Python เป็นเครื่องมือที่มีประโยชน์สำหรับการกำหนดฟังก์ชันแบบชั่วคราวและกระชับ มักใช้งานในฟังก์ชันระดับสูงหรือการดำเนินการในรายการเพื่อกำหนดเงื่อนไขเฉพาะอย่างกระชับ อย่างไรก็ตาม ฟังก์ชัน lambda ควรจำกัดการใช้งานสำหรับงานง่าย โดยใช้ฟังก์ชัน def ในการดำเนินตรรกะที่ซับซ้อน

คุณสามารถติดตามบทความข้างต้นโดยใช้ Visual Studio Code บนช่อง YouTube ของเรา กรุณาตรวจสอบช่อง YouTube ด้วย

YouTube Video