ทำไมต้องเก็บฟังก์ชั่นภายในพจนานุกรมหลาม?

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

ตัวอย่างที่ฉันใช้งานมาจาก Learn Python the Hard Way, 2nd Ed (นี่เป็นรุ่นที่มีให้เมื่อคุณสมัครใช้งานผ่านUdemy.comแต่น่าเสียดายที่เวอร์ชัน HTML ที่ใช้งานได้ฟรีปัจจุบันเป็น Ed 3 และไม่มีตัวอย่างนี้อีกต่อไป)

ในการถอดความ:

# make a dictionary of US states and major cities
cities = {'San Diego':'CA', 'New York':'NY', 'Detroit':'MI'}

# define a function to use on such a dictionary
def find_city (map, city):
    # does something, returns some value
    if city in map:
        return map[city]
    else:
        return "Not found"

# then add a final dict element that refers to the function
cities['_found'] = find_city

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

>>> find_city (cities, 'New York')
NY

>>> cities['_found'](cities, 'New York')
NY

บางคนสามารถอธิบายคุณลักษณะของภาษานี้ได้และบางทีมันอาจจะเล่นที่ไหนในการเขียนโปรแกรม "ของจริง" แบบฝึกหัดของเล่นนี้เพียงพอที่จะสอนฉันเกี่ยวกับไวยากรณ์ แต่ไม่ได้พาฉันไปที่นั่น

การใช้ dict ให้คุณแปลคีย์เป็น callable กุญแจไม่จำเป็นต้องฮาร์ดโค้ดเหมือนเช่นในตัวอย่างของคุณ

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

def do_ping(self, arg):
    return 'Pong, {0}!'.format(arg)

def do_ls(self, arg):
    return '\n'.join(os.listdir(arg))

dispatch = {
    'ping': do_ping,
    'ls': do_ls,
}

def process_network_command(command, arg):
    send(dispatch[command](arg))

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

การใช้วิธีการแจกจ่ายนั้นปลอดภัยกว่าเทคนิคอื่น ๆ เช่นeval()เนื่องจากมัน จำกัด คำสั่งที่อนุญาตให้ใช้กับสิ่งที่คุณกำหนดไว้ล่วงหน้า ผู้โจมตีจะไม่แอบเข้าไปls)"; DROP TABLE Students; --ฉีดที่โต๊ะส่งตัวอย่างเช่น

@Martijn Pieters ทำได้ดีมากในการอธิบายเทคนิค แต่ฉันต้องการที่จะอธิบายบางสิ่งบางอย่างจากคำถามของคุณ

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

>>> def f():
...   print 1
... 
>>> print f
<function f at 0xb721c1b4>

fเป็นเพียงตัวแปรที่อ้างอิงฟังก์ชันที่คุณกำหนด การใช้พจนานุกรมช่วยให้คุณจัดกลุ่มสิ่งต่าง ๆ ได้ แต่ไม่แตกต่างจากการกำหนดฟังก์ชันให้กับตัวแปรที่แตกต่างกัน

>>> a = f
>>> a
<function f at 0xb721c3ac>
>>> a()
1

ในทำนองเดียวกันคุณสามารถส่งผ่านฟังก์ชั่นเป็นอาร์กิวเมนต์

>>> def c(func):
...   func()
... 
>>> c(f)
1

โปรดทราบว่าคลาส Python เป็นเพียงน้ำตาลไวยากรณ์สำหรับพจนานุกรม เมื่อคุณทำ:

class Foo(object):
    def find_city(self, city):
        ...

เมื่อคุณโทร

f = Foo()
f.find_city('bar')

เป็นเช่นเดียวกับ:

getattr(f, 'find_city')('bar')

ซึ่งหลังจากการแก้ไขชื่อแล้วก็เหมือนกับ:

f.__class__.__dict__['find_city'](f, 'bar')

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

def cb1(...): 
    ...
funcs = {
    'cb1': cb1,
    ...
}
while True:
    input = raw_input()
    funcs[input]()

อีกทางเลือกหนึ่งสามารถเขียนในชั้นเรียน:

class Funcs(object):
    def cb1(self, a): 
        ...
funcs = Funcs()
while True:
    input = raw_input()
    getattr(funcs, input)()

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

มีเทคนิค 2 อย่างที่กระโดดไปในใจของฉันซึ่งคุณอาจจะอ้างถึงไม่ได้ซึ่งก็คือไพทอนในสิ่งที่พวกเขาเป็นมากกว่าภาษาเดียว

1. เทคนิคการซ่อนข้อมูล / การห่อหุ้มและการรวมตัวกัน (โดยปกติแล้วพวกเขาจะจับมือกันดังนั้นฉันจึงจับพวกมันเข้าด้วยกัน)

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

2. ส่งตาราง

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

ความสมดุล

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

ฉันโพสต์วิธีแก้ปัญหาที่ฉันคิดว่าค่อนข้างทั่วไปและมีประโยชน์เพราะมันง่ายและปรับให้เข้ากับกรณีเฉพาะ:

def p(what):
    print 'playing', cmpsr

def l(what):
    print 'listening', cmpsr

actions = {'Play' : p, 'Listen' : l}

act = 'Listen'
cmpsr = 'Vivaldi'

actions[act].__call__(cmpsr)

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

"ศิลปินผู้ยิ่งใหญ่คือซิมป์" Henri Frederic Amiel