ฟังก์ชันแลมบ์ดาในไพธอน

ฟังก์ชั่นแลมบ์ดาใน Python คืออะไร?

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

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

• คีย์เวิร์ดแลมบ์ดา
• พารามิเตอร์ (หรือตัวแปรที่ถูกผูกไว้) และ
• ฟังก์ชั่นร่างกาย

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

ในบทช่วยสอน Lambda ใน Python คุณจะได้เรียนรู้:

• ไวยากรณ์และตัวอย่าง
• การใช้แลมบ์ดากับ Python ในตัว
• แลมบ์ดาในตัวกรอง ()
• แลมบ์ดาใน map()
• แลมบ์ดาใน reduce()
• ทำไม (และทำไมไม่) ใช้ฟังก์ชันแลมบ์ดา?
• แลมบ์ดาส vs. ฟังก์ชั่นปกติ

ไวยากรณ์และตัวอย่าง

ไวยากรณ์ที่เป็นทางการในการเขียนฟังก์ชันแลมบ์ดามีดังต่อไปนี้:

แลมบ์ดา p1, p2: นิพจน์

ที่นี่ p1 และ p2 เป็นพารามิเตอร์ที่ส่งผ่านไปยังฟังก์ชันแลมบ์ดา คุณสามารถเพิ่มพารามิเตอร์ได้มากหรือน้อยตามที่คุณต้องการ

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

ตัวอย่าง 1

ตอนนี้คุณรู้เกี่ยวกับแลมบ์ดาแล้ว มาลองใช้ตัวอย่างกัน ดังนั้น เปิด IDLE ของคุณและพิมพ์ดังต่อไปนี้:

แอดเดอร์ = แลมบ์ดา x, y: x + y
พิมพ์ (แอดเดอร์ (1, 2))

นี่คือผลลัพธ์:

3

คำอธิบายรหัส

ที่นี่ เรากำหนดตัวแปรที่จะเก็บผลลัพธ์ที่ส่งคืนโดยฟังก์ชันแลมบ์ดา

1.คีย์เวิร์ดแลมบ์ดาใช้เพื่อกำหนดฟังก์ชันที่ไม่ระบุชื่อ

2. x และ y เป็นพารามิเตอร์ที่เราส่งผ่านไปยังฟังก์ชันแลมบ์ดา

3.นี่คือเนื้อความของฟังก์ชัน ซึ่งเพิ่ม 2 พารามิเตอร์ที่เราส่งผ่าน สังเกตว่ามันเป็นนิพจน์เดียว คุณไม่สามารถเขียนหลายคำสั่งในเนื้อความของฟังก์ชันแลมบ์ดา

4.เราเรียกใช้ฟังก์ชันและพิมพ์ค่าที่ส่งคืน

ตัวอย่าง 2

นั่นเป็นตัวอย่างพื้นฐานในการทำความเข้าใจพื้นฐานและไวยากรณ์ของแลมบ์ดา ทีนี้ลองพิมพ์แลมบ์ดาดูผลลัพธ์กัน อีกครั้ง เปิด IDLE ของคุณและพิมพ์ดังต่อไปนี้:

#สิ่งที่แลมบ์ดากลับมา
string='แลมบ์ดาไร้ประโยชน์บางชนิด'
พิมพ์ (สตริงแลมบ์ดา : พิมพ์ (สตริง))

 

ตอนนี้บันทึกไฟล์ของคุณแล้วกด F5 เพื่อเรียกใช้โปรแกรม นี่คือผลลัพธ์ที่คุณควรได้รับ

 

เอาท์พุท:

<ฟังก์ชัน <แลมบ์ดา> ที่ 0x00000185C3BF81E0>

เกิดอะไรขึ้นที่นี่? ลองดูรหัสเพื่อทำความเข้าใจเพิ่มเติม

คำอธิบายรหัส

1. ที่นี่ เรากำหนดสตริงที่คุณจะส่งผ่านเป็นพารามิเตอร์ไปยังแลมบ์ดา
2. เราประกาศแลมบ์ดาที่เรียกใช้คำสั่งพิมพ์และพิมพ์ผลลัพธ์

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

ตัวอย่างที่ 3

อย่างไรก็ตาม หากคุณเขียนโปรแกรมในลักษณะนี้:

#สิ่งที่แลมบ์ดาส่งคืน #2
x="แลมบ์ดาที่ไร้ประโยชน์"
(แลมบ์ดา x : พิมพ์(x))(x)

และเรียกใช้โดยกด F5 คุณจะเห็นผลลัพธ์เช่นนี้

เอาท์พุท:

แลมบ์ดาที่ไร้ประโยชน์

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

คำอธิบายรหัส

1. นี่คือสตริงเดียวกับที่เรากำหนดไว้ในตัวอย่างก่อนหน้านี้
2. ในส่วนนี้ เรากำลังกำหนดแลมบ์ดาและเรียกมันทันทีโดยส่งสตริงเป็นอาร์กิวเมนต์ นี่คือสิ่งที่เรียกว่า IIFE และคุณจะได้เรียนรู้เพิ่มเติมเกี่ยวกับมันในหัวข้อถัดไปของบทช่วยสอนนี้

ตัวอย่างที่ 4

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

#ฟังก์ชั่นปกติ
def guru( funct, *args ):
ฟังก์ชั่น ( *args )
def printer_one( หาเรื่อง ):
ส่งคืนพิมพ์ (arg)
def printer_two( หาเรื่อง ):
พิมพ์ (หาเรื่อง)
#เรียกฟังก์ชั่นปกติ
guru ( printer_one, 'printer 1 REGULAR CALL' )
guru( printer_two, 'printer 2 REGULAR CALL \n' )
#เรียกฟังก์ชั่นปกติผ่านแลมบ์ดา
กูรู(แลมบ์ดา: printer_one('เครื่องพิมพ์ 1 LAMBDA CALL'))
guru(แลมบ์ดา: printer_two('เครื่องพิมพ์ 2 LAMBDA CALL'))

ตอนนี้บันทึกไฟล์แล้วกด F5 เพื่อเรียกใช้โปรแกรม หากคุณไม่ได้ทำผิดพลาดใดๆ ผลลัพธ์ควรเป็นประมาณนี้

เอาท์พุท:

เครื่องพิมพ์ 1 REGULAR CALL

เครื่องพิมพ์ 2 REGULAR CALL

เครื่องพิมพ์ 1 LAMBDA CALL

เครื่องพิมพ์ 2 LAMBDA CALL

คำอธิบายรหัส

1. ฟังก์ชันที่เรียกว่า guru ซึ่งรับฟังก์ชันอื่นเป็นพารามิเตอร์แรกและอาร์กิวเมนต์อื่นๆ ที่ตามมา
2. printer_one เป็นฟังก์ชันง่าย ๆ ที่พิมพ์พารามิเตอร์ที่ส่งไปและส่งคืน
3. printer_two คล้ายกับ printer_one แต่ไม่มีคำสั่ง return
4. ในส่วนนี้ เรากำลังเรียกใช้ฟังก์ชัน guru และส่งฟังก์ชันเครื่องพิมพ์และสตริงเป็นพารามิเตอร์
5. นี่คือไวยากรณ์เพื่อให้บรรลุขั้นตอนที่สี่ (เช่น การเรียกใช้ฟังก์ชันกูรู) แต่ใช้แลมบ์ดาส

ในส่วนถัดไป คุณจะได้เรียนรู้วิธีใช้ฟังก์ชันแลมบ์ดากับmap(), reduce()และfilter()ใน Python

 

การใช้แลมบ์ดากับ Python ในตัว

ฟังก์ชัน Lambda เป็นวิธีที่สง่างามและมีประสิทธิภาพในการดำเนินการโดยใช้วิธีการในตัวใน Python เป็นไปได้เนื่องจากสามารถเรียกใช้ lambdas ได้ทันทีและส่งผ่านเป็นอาร์กิวเมนต์ของฟังก์ชันเหล่านี้

IIFE ใน Python Lambda

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

(แลมบ์ดา x: x + x)(2)

นี่คือคำอธิบายผลลัพธ์และรหัส:

ความสามารถของ lambdas ที่จะถูกเรียกใช้ทันทีทำให้คุณสามารถใช้พวกมันในฟังก์ชันต่างๆ เช่น map() และ reduce() มีประโยชน์เพราะคุณอาจไม่ต้องการใช้ฟังก์ชันเหล่านี้อีก

แลมบ์ดาในตัวกรอง ()

ฟังก์ชันตัวกรองใช้เพื่อเลือกองค์ประกอบเฉพาะบางส่วนจากลำดับขององค์ประกอบ ลำดับสามารถเป็นตัววนซ้ำใดๆ เช่น รายการ ชุด ทูเปิล ฯลฯ

องค์ประกอบที่จะเลือกจะขึ้นอยู่กับข้อจำกัดที่กำหนดไว้ล่วงหน้าบางประการ ใช้พารามิเตอร์ 2 ตัว:

• ฟังก์ชันที่กำหนดข้อจำกัดการกรอง
• ลำดับ (ตัววนซ้ำใดๆ เช่น รายการ สิ่งอันดับ ฯลฯ)

ตัวอย่างเช่น,

ลำดับ = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = ตัวกรอง (แลมบ์ดา x: x > 4 ลำดับ)
พิมพ์(รายการ(กรอง_ผล))

นี่คือผลลัพธ์:

[10, 8, 7, 5, 11]

คำอธิบายรหัส:

1.ในคำสั่งแรก เรากำหนดรายการที่เรียกว่า ลำดับ ซึ่งมีตัวเลขอยู่บ้าง

2.ที่นี่ เราประกาศตัวแปรที่เรียกว่า filtered_result ซึ่งจะเก็บค่าที่กรองแล้วที่ส่งกลับโดยฟังก์ชัน filter()

3.ฟังก์ชันแลมบ์ดาที่ทำงานบนแต่ละองค์ประกอบของรายการและคืนค่า จริง หากมีค่ามากกว่า 4

4.พิมพ์ผลลัพธ์ที่ส่งคืนโดยฟังก์ชันตัวกรอง

แลมบ์ดาใน map()

ฟังก์ชันแผนที่ใช้เพื่อปรับใช้การดำเนินการเฉพาะกับทุกองค์ประกอบในลำดับ เช่นเดียวกับ filter() ก็ใช้พารามิเตอร์ 2 ตัวเช่นกัน:

1. ฟังก์ชั่นที่กำหนด op เพื่อดำเนินการกับองค์ประกอบ
2. หนึ่งลำดับขึ้นไป

ตัวอย่างเช่น นี่คือโปรแกรมที่พิมพ์กำลังสองของตัวเลขในรายการที่กำหนด:

ลำดับ = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = แผนที่ (แลมบ์ดา x: xxxx, ลำดับ)
พิมพ์(รายการ(กรอง_ผล))

เอาท์พุท:

 [100, 4, 64, 49, 25, 16, 9, 121, 0, 1]

[KR1]

คำอธิบายรหัส:

1. ที่นี่ เรากำหนดรายการที่เรียกว่าลำดับซึ่งมีตัวเลขอยู่บ้าง
2. เราประกาศตัวแปรที่เรียกว่า filtered_result ซึ่งจะเก็บค่าที่แมปไว้
3. ฟังก์ชันแลมบ์ดาที่ทำงานบนแต่ละองค์ประกอบของรายการและส่งกลับค่ากำลังสองของตัวเลขนั้น
4. พิมพ์ผลลัพธ์ที่ส่งคืนโดยฟังก์ชันแผนที่

แลมบ์ดาใน reduce()

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

ขั้นตอนที่ 1)ดำเนินการตามที่กำหนดไว้ใน 2 องค์ประกอบแรกของลำดับ

ขั้นตอนที่ 2)บันทึกผลลัพธ์นี้

ขั้นตอนที่ 3)ดำเนินการกับผลลัพธ์ที่บันทึกไว้และองค์ประกอบถัดไปในลำดับ

ขั้นตอนที่ 4)ทำซ้ำจนกว่าจะไม่มีองค์ประกอบเหลืออยู่

นอกจากนี้ยังใช้สองพารามิเตอร์:

1. ฟังก์ชันที่กำหนดการดำเนินการที่จะดำเนินการ
2. ลำดับ (ตัววนซ้ำใดๆ เช่น รายการ สิ่งอันดับ ฯลฯ)

ตัวอย่างเช่น นี่คือโปรแกรมที่ส่งคืนผลิตภัณฑ์ขององค์ประกอบทั้งหมดในรายการ:

จาก functools นำเข้าลด
ลำดับ = [1,2,3,4,5]
ผลิตภัณฑ์ = ลด (แลมบ์ดา x, y: x*y, ลำดับ)
พิมพ์ (สินค้า)

นี่คือผลลัพธ์:

120

คำอธิบายรหัส:

1. นำเข้าลดจากโมดูล functools
2. ที่นี่ เรากำหนดรายการที่เรียกว่าลำดับซึ่งมีตัวเลขอยู่บ้าง
3. เราประกาศตัวแปรที่เรียกว่า product ซึ่งจะเก็บค่าที่ลดลง
4. ฟังก์ชันแลมบ์ดาที่ทำงานบนแต่ละองค์ประกอบของรายการ มันจะส่งคืนผลิตภัณฑ์ของหมายเลขนั้นตามผลลัพธ์ก่อนหน้า
5. พิมพ์ผลลัพธ์ที่ส่งคืนโดยฟังก์ชันลด

ทำไม (และทำไมไม่) ใช้ฟังก์ชันแลมบ์ดา?

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

อย่างไรก็ตาม คุณควรรู้ว่าเมื่อใดควรใช้แลมบ์ดาและควรหลีกเลี่ยงเมื่อใด ในส่วนนี้ คุณจะได้เรียนรู้หลักการออกแบบที่นักพัฒนา python ใช้เมื่อเขียน lambdas

กรณีการใช้งานที่พบบ่อยที่สุดกรณีหนึ่งสำหรับ lambdas คือในการเขียนโปรแกรมเชิงฟังก์ชัน เนื่องจาก Python รองรับกระบวนทัศน์ (หรือรูปแบบ) ของการเขียนโปรแกรมที่เรียกว่า functional programming

ช่วยให้คุณสามารถจัดเตรียมฟังก์ชันเป็นพารามิเตอร์ให้กับฟังก์ชันอื่นได้ (เช่น ในแผนที่ ตัวกรอง ฯลฯ) ในกรณีเช่นนี้ การใช้แลมบ์ดาเป็นวิธีการที่สวยงามในการสร้างฟังก์ชันแบบใช้ครั้งเดียวและส่งผ่านเป็นพารามิเตอร์

เมื่อใดที่คุณไม่ควรใช้ Lambda

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

แลมบ์ดาส vs. ฟังก์ชั่นปกติ

ตามที่ระบุไว้ก่อนหน้านี้ lambdas are[vV4][J5] เป็นเพียงฟังก์ชันที่ไม่มีตัวระบุที่ผูกไว้กับพวกมัน พูดง่ายๆ ก็คือ เป็นฟังก์ชันที่ไม่มีชื่อ (ดังนั้นจึงไม่ระบุชื่อ) นี่คือตารางที่แสดงความแตกต่างระหว่าง lambdas และฟังก์ชันปกติใน python

แลมบ์ดาส

ฟังก์ชั่นปกติ

ไวยากรณ์:

แลมบ์ดา x : x + x

ไวยากรณ์:

def (x) :
ส่งคืน x + x

ฟังก์ชันแลมบ์ดาสามารถมีนิพจน์ในร่างกายได้เพียงอันเดียว

ฟังก์ชันปกติสามารถมีหลายนิพจน์และคำสั่งในร่างกายได้

แลมบ์ดาสไม่มีชื่อที่เกี่ยวข้องกับพวกเขา นั่นเป็นเหตุผลว่าทำไมจึงเรียกว่าฟังก์ชันที่ไม่ระบุตัวตน

ฟังก์ชันปกติต้องมีชื่อและลายเซ็น

Lambdas ไม่มีคำสั่ง return เนื่องจากเนื้อความจะถูกส่งกลับโดยอัตโนมัติ

ฟังก์ชันที่ต้องการคืนค่าควรรวมคำสั่ง return

คำอธิบายของความแตกต่าง?

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

ฟังก์ชันปกติสำหรับตัวอย่างข้างต้นจะมีลักษณะดังนี้:

def adder (x, y):
คืนค่า x + y
พิมพ์ (แอดเดอร์ (1, 2))

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

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

ดังที่คุณเห็นในไดอะแกรม คำจำกัดความทั้งสองได้รับการจัดการในลักษณะเดียวกันโดยล่าม python เมื่อแปลงเป็น bytecode ตอนนี้ คุณไม่สามารถตั้งชื่อฟังก์ชันlambdaได้เนื่องจาก Python สงวนไว้ แต่ชื่อฟังก์ชันอื่นจะให้ผลเป็น bytecode[KR6] เดียวกัน

สรุป

• Lambdas หรือที่เรียกว่าฟังก์ชันนิรนาม เป็นฟังก์ชันขนาดเล็กที่จำกัดซึ่งไม่ต้องการชื่อ (กล่าวคือ ตัวระบุ)
• ทุกฟังก์ชันแลมบ์ดาใน Python มี 3 ส่วนที่สำคัญ:
• คีย์เวิร์ดแลมบ์ดา
• พารามิเตอร์ (หรือตัวแปรที่ถูกผูกไว้) และ
• ฟังก์ชั่นร่างกาย
• ไวยากรณ์สำหรับการเขียนแลมบ์ดาคือ: พารามิเตอร์แลมบ์ดา: expression
• Lambdas สามารถมีพารามิเตอร์จำนวนเท่าใดก็ได้ แต่ไม่ได้อยู่ในวงเล็บปีกกา
• แลมบ์ดาสามารถมีได้เพียง 1 นิพจน์ในเนื้อหาของฟังก์ชัน ซึ่งส่งคืนโดยค่าเริ่มต้น
• ที่ระดับ bytecode ไม่มีความแตกต่างมากนักระหว่างวิธีจัดการ lambdas และฟังก์ชันปกติโดยล่าม
• Lambdas รองรับ IIFE ผ่านไวยากรณ์นี้: (พารามิเตอร์แลมบ์ดา: นิพจน์)(อาร์กิวเมนต์)
• โดยทั่วไปแล้ว Lambdas จะใช้กับ python ในตัวต่อไปนี้:
• ตัวกรอง: ตัวกรอง (พารามิเตอร์แลมบ์ดา: expression, iterable-sequence)
• Map: map (พารามิเตอร์ lambda: expression, iterable-sequences)
• ลด: ลด (พารามิเตอร์แลมบ์ดา 1, พารามิเตอร์ 2: นิพจน์, ลำดับซ้ำได้)
• อย่าเขียนฟังก์ชันแลมบ์ดาที่ซับซ้อนในสภาพแวดล้อมการใช้งานจริง เนื่องจากจะเป็นเรื่องยากสำหรับผู้ดูแลโค้ด

[J5]ฉันได้เพิ่มตารางแล้ว แต่คำอธิบายจำเป็นต้องเข้าใจความแตกต่าง

Posted in: