0Pricing
Python Academy · บทเรียน

คลอเชอร์และตัวแปรอิสระ

เก็บสถานะในฟังก์ชันด้านใน

คลอเชอร์และตัวแปรอิสระ เป็นบทเรียน Python Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Python Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Python Academy มีบทเรียนทั้งหมด 4 บทเรียน

ฟังก์ชันซ้อนกัน

Python อนุญาตให้คุณกำหนดฟังก์ชันภายในฟังก์ชันอื่นได้ ฟังก์ชันด้านในจะถูกสร้างขึ้นใหม่ทุกครั้งที่ฟังก์ชันด้านนอกทำงาน

def outer():
    def inner():
        return 'from inner'
    return inner()
print(outer())

ฟังก์ชันด้านในมองเห็นตัวแปรด้านนอก

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

def outer():
    message = 'hello'
    def inner():
        return message
    return inner()
print(outer())

คลอเชอร์คืออะไร

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

def make_greeter(name):
    def greet():
        return 'Hi ' + name
    return greet
g = make_greeter('Ada')
print(g())

สถานะที่จับไว้ยังคงอยู่

ฟังก์ชันด้านนอกส่งคืนไปแล้ว แต่คลอเชอร์ยังคงเก็บ name ไว้ ค่า ​​นี้ยังคงอยู่ภายในฟังก์ชันที่ส่งคืนมา

def make_greeter(name):
    def greet():
        return 'Hi ' + name
    return greet
a = make_greeter('Ada')
b = make_greeter('Bob')
print(a())
print(b())

โรงงานสร้าง multiplier

คลอเชอร์มีประโยชน์อย่างยิ่งในฐานะโรงงานที่สร้างฟังก์ชันแบบปรับแต่งได้ ในที่นี้ฟังก์ชันที่ส่งคืนมาแต่ละฟังก์ชันจะคูณด้วยตัวคูณที่ถูกจับไว้

def multiplier(factor):
    def multiply(n):
        return n * factor
    return multiply
double = multiplier(2)
triple = multiplier(3)
print(double(10))
print(triple(10))

คลอเชอร์แต่ละรายการเป็นอิสระต่อกัน

การเรียกใช้โรงงานแต่ละครั้งจะสร้างคลอเชอร์แยกกัน พร้อมค่าที่ถูกจับไว้ของตนเอง คลอเชอร์เหล่านี้ไม่รบกวนกัน

def adder(amount):
    def add(n):
        return n + amount
    return add
add5 = adder(5)
add100 = adder(100)
print(add5(1), add100(1))

การตรวจสอบค่าที่คลอเชอร์เก็บไว้

ชื่อที่ถูกจับไว้จะแสดงอยู่ใน __code__.co_freevars ส่วนค่าของชื่อเหล่านั้นอยู่ในเซลล์ของ __closure__

def make(x):
    def f():
        return x
    return f
fn = make(42)
print(fn.__code__.co_freevars)
print(fn.__closure__[0].cell_contents)

คลอเชอร์จับตัวแปร ไม่ใช่ค่า

คลอเชอร์จับตัวแปรเอง จึงเห็นค่าล่าสุดของตัวแปรนั้น เรื่องนี้สำคัญเมื่อตัวแปรเปลี่ยนค่าหลังจากสร้างคลอเชอร์แล้ว

def build():
    x = 1
    def show():
        return x
    x = 99
    return show
print(build()())

กับดักลูปการผูกค่าล่าช้า

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

funcs = []
for i in range(3):
    funcs.append(lambda: i)
print([f() for f in funcs])

การแก้ปัญหาการผูกค่าล่าช้า

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

funcs = []
for i in range(3):
    funcs.append(lambda i=i: i)
print([f() for f in funcs])

คลอเชอร์ในฐานะอ็อบเจกต์น้ำหนักเบา

คลอเชอร์รวมข้อมูลเข้ากับพฤติกรรมไว้ด้วยกัน คล้ายอ็อบเจกต์ขนาดเล็ก จึงมักสะอาดกว่าการใช้คลาสเต็มรูปแบบในกรณีง่าย ๆ

def counter_start(start):
    def value():
        return start
    return value
c = counter_start(10)
print(c())

ตรวจสอบความเข้าใจ

คลอเชอร์ใน Python คืออะไร

สรุปทบทวน: คลอเชอร์และตัวแปรอิสระ

แนวคิดสำคัญ:

  • ฟังก์ชันด้านในสามารถอ่านตัวแปรจากขอบเขตที่ครอบอยู่ได้ ซึ่งเรียกว่าตัวแปรอิสระ
  • คลอเชอร์คือฟังก์ชันด้านในที่ถูกส่งคืนและจดจำตัวแปรเหล่านั้นไว้
  • การเรียกใช้โรงงานแต่ละครั้งจะสร้างคลอเชอร์ที่เป็นอิสระต่อกัน
  • คลอเชอร์จับตัวแปร ไม่ใช่ค่า จึงทำให้เกิดกับดักการผูกค่าล่าช้าในลูป ซึ่งแก้ไขได้ด้วยอาร์กิวเมนต์ค่าเริ่มต้น
def power_of(exp):
    return lambda base: base ** exp
square = power_of(2)
print(square(9))

คำถามที่พบบ่อย

บทเรียน “คลอเชอร์และตัวแปรอิสระ” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “คลอเชอร์และตัวแปรอิสระ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Python Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Python Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “คลอเชอร์และตัวแปรอิสระ”

เก็บสถานะในฟังก์ชันด้านใน คุณปฏิบัติ Python Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Python Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Python Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “คลอเชอร์และตัวแปรอิสระ” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Python Academy นี้ได้ไหม

ได้ บทเรียน Python Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. ฟังก์ชันชั้นหนึ่ง
  2. คลอเชอร์และตัวแปรอิสระ
  3. nonlocal และสถานะที่เปลี่ยนแปลงได้
  4. ฟังก์ชันบางส่วน
← กลับไปที่ Python Academy