pythonic นำเข้าฟังก์ชันภายในหรือไม่?

PEP 8พูดว่า:

• การนำเข้าจะถูกวางไว้ที่ด้านบนสุดของไฟล์เสมอหลังจากความคิดเห็นของโมดูลและ docstrings ใด ๆ และก่อนโมดูลและค่าคงที่ของโมดูล

ในเหตุการณ์ที่เกิดขึ้นฉันละเมิด PEP 8 บางครั้งฉันนำเข้าสิ่งที่อยู่ในฟังก์ชัน ตามกฎทั่วไปฉันจะทำเช่นนี้หากมีการนำเข้าที่ใช้ภายในฟังก์ชันเดียวเท่านั้น

มีความคิดเห็นอย่างไร

แก้ไข (เหตุผลที่ฉันรู้สึกว่าการนำเข้าในฟังก์ชันอาจเป็นความคิดที่ดี):

เหตุผลหลัก: สามารถทำให้โค้ดชัดเจนขึ้น

• เมื่อดูโค้ดของฟังก์ชันฉันอาจถามตัวเองว่า "function / class xxx คืออะไร" (xxx ถูกใช้ภายในฟังก์ชัน) หากฉันมีการนำเข้าทั้งหมดที่ด้านบนของโมดูลฉันต้องไปดูที่นั่นเพื่อดูว่า xxx คืออะไร from m import xxxนี้มีมากขึ้นของปัญหาเมื่อใช้ เห็นm.xxxในฟังก์ชั่นคงบอกอะไรได้มากกว่านี้ ขึ้นอยู่กับว่าmคืออะไร: เป็นโมดูล / แพ็คเกจระดับบนสุด ( import m) ที่รู้จักกันดีหรือไม่? หรือเป็นโมดูลย่อย / แพ็กเกจ ( from a.b.c import m)?
• ในบางกรณีการมีข้อมูลเพิ่มเติมนั้น ("xxx คืออะไร") ใกล้กับตำแหน่งที่ใช้ xxx อาจทำให้เข้าใจฟังก์ชันได้ง่ายขึ้น

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

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

อีกประเด็นหนึ่งฉันชอบที่จะได้รับImportErrorข้อยกเว้นก่อนที่จะเรียกใช้โค้ดใด ๆ - เป็นการตรวจสอบความมีเหตุผลดังนั้นจึงเป็นอีกเหตุผลหนึ่งในการนำเข้าที่ด้านบน

ฉันใช้pyCheckerเพื่อตรวจสอบโมดูลที่ไม่ได้ใช้งาน

มีสองครั้งที่ฉันละเมิด PEP 8 ในเรื่องนี้:

• การนำเข้าแบบวงกลม: โมดูล A นำเข้าโมดูล B แต่บางสิ่งในโมดูล B ต้องการโมดูล A (แม้ว่านี่จะเป็นสัญญาณว่าฉันจำเป็นต้อง refactor โมดูลเพื่อกำจัดการพึ่งพาแบบวงกลม)
• การใส่เบรกพอยต์ pdb: import pdb; pdb.set_trace()นี่เป็น b / c ที่มีประโยชน์ฉันไม่ต้องการวางไว้import pdbที่ด้านบนของทุกโมดูลที่ฉันอาจต้องการดีบักและอย่าลืมลบการนำเข้าเมื่อฉันลบเบรกพอยต์

นอกสองกรณีนี้คุณควรวางทุกอย่างไว้ที่ด้านบนสุด ทำให้การอ้างอิงชัดเจนขึ้น

นี่คือกรณีการนำเข้าสี่กรณีที่เราใช้

1. import(และfrom x import yและimport x as y) ที่ด้านบน

2. ทางเลือกสำหรับการนำเข้า ที่ด้านบน.

   import settings
   if setting.something:
       import this as foo
   else:
       import that as foo
   

3. การนำเข้าตามเงื่อนไข ใช้กับ JSON ไลบรารี XML และอื่น ๆ ที่ด้านบน.

   try:
       import this as foo
   except ImportError:
       import that as foo
   

4. การนำเข้าแบบไดนามิก จนถึงตอนนี้เรามีเพียงตัวอย่างเดียวเท่านั้น

   import settings
   module_stuff = {}
   module= __import__( settings.some_module, module_stuff )
   x = module_stuff['x']
   

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

   นี่คือมากหรือน้อยที่ด้านบนของโมดูล

นี่คือสิ่งที่เราทำเพื่อให้โค้ดชัดเจนขึ้น:

• ทำให้โมดูลสั้น

• หากฉันมีการนำเข้าทั้งหมดที่ด้านบนของโมดูลฉันต้องไปดูที่นั่นเพื่อพิจารณาว่าชื่ออะไร หากโมดูลสั้นก็ทำได้ง่าย

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

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

หากคุณกำลังทำ IronPython ฉันจะบอกว่าการนำเข้าฟังก์ชันภายในจะดีกว่า (เนื่องจากการรวบรวมโค้ดใน IronPython อาจช้า) ดังนั้นคุณอาจสามารถหาวิธีการนำเข้าฟังก์ชันภายในได้แล้ว แต่นอกเหนือจากนั้นฉันขอยืนยันว่ามันไม่คุ้มค่าที่จะต่อสู้กับอนุสัญญา

ตามกฎทั่วไปฉันจะทำเช่นนี้หากมีการนำเข้าที่ใช้ภายในฟังก์ชันเดียวเท่านั้น

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

FWIW มีหลายกรณีที่ควรนำเข้าภายในฟังก์ชัน ตัวอย่างเช่นหากคุณต้องการตั้งค่าภาษาใน cx_Oracle คุณต้องตั้งค่า_ตัวแปรสภาพแวดล้อมNLS LANG ก่อนที่จะนำเข้า ดังนั้นคุณอาจเห็นรหัสดังนี้:

import os

oracle = None

def InitializeOracle(lang):
    global oracle
    os.environ['NLS_LANG'] = lang
    import cx_Oracle
    oracle = cx_Oracle

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

มาจากคำถามเกี่ยวกับการโหลดโมดูลสองครั้ง - ทำไมไม่ทั้งสองอย่าง?

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

ตราบใดที่ยังimportไม่ใช่from x import *คุณควรวางไว้ที่ด้านบน เพิ่มชื่อเพียงชื่อเดียวในเนมสเปซส่วนกลางและคุณติด PEP 8 นอกจากนี้หากคุณต้องการใช้ที่อื่นในภายหลังคุณก็ไม่ต้องย้ายอะไรไปรอบ ๆ

ไม่ใช่เรื่องใหญ่ แต่เนื่องจากแทบไม่มีความแตกต่างฉันจึงขอแนะนำให้ทำตามที่ PEP 8 พูด

ลองดูแนวทางอื่นที่ใช้ใน sqlalchemy: dependency injection:

@util.dependencies("sqlalchemy.orm.query")
def merge_result(query, *args):
    #...
    query.Query(...)

สังเกตว่าไลบรารีที่นำเข้ามีการประกาศในมัณฑนากรอย่างไรและส่งผ่านเป็นอาร์กิวเมนต์ไปยังฟังก์ชัน !

วิธีนี้ทำให้โค้ดสะอาดขึ้นและยังทำงานได้เร็วกว่าimportคำสั่ง4.5 เท่า !

เกณฑ์มาตรฐาน: https://gist.github.com/kolypto/589e84fbcfb6312532658df2fabdb796

ในโมดูลที่เป็นทั้งโมดูล 'ปกติ' และสามารถเรียกใช้งานได้ (เช่นมี a if __name__ == '__main__':-section) ฉันมักจะนำเข้าโมดูลที่ใช้เมื่อเรียกใช้โมดูลภายในส่วนหลักเท่านั้น

ตัวอย่าง:

def really_useful_function(data):
    ...


def main():
    from pathlib import Path
    from argparse import ArgumentParser
    from dataloader import load_data_from_directory

    parser = ArgumentParser()
    parser.add_argument('directory')
    args = parser.parse_args()
    data = load_data_from_directory(Path(args.directory))
    print(really_useful_function(data)


if __name__ == '__main__':
    main()

มีอีกกรณีหนึ่ง (อาจเป็น "มุม") ที่อาจเป็นประโยชน์ต่อimportฟังก์ชันที่ไม่ค่อยได้ใช้งานภายใน: ลดเวลาเริ่มต้น

ฉันชนกำแพงนั้นครั้งหนึ่งด้วยโปรแกรมที่ค่อนข้างซับซ้อนที่ทำงานบนเซิร์ฟเวอร์ IoT ขนาดเล็กที่ยอมรับคำสั่งจากสายอนุกรมและดำเนินการซึ่งอาจเป็นการดำเนินการที่ซับซ้อนมาก

การวางimportคำสั่งที่ด้านบนของไฟล์หมายถึงการประมวลผลการนำเข้าทั้งหมดก่อนที่เซิร์ฟเวอร์จะเริ่มทำงาน ตั้งแต่importรายการรวมjinja2, lxml, signxmlและอื่น ๆ "หนัก" (SoC และก็ไม่ได้มีประสิทธิภาพมาก) นี่หมายความนาทีก่อนที่จะมีการเรียนการสอนเป็นครั้งแรกที่ดำเนินการจริง

OTOH วางการนำเข้าส่วนใหญ่ในฟังก์ชั่นฉันสามารถทำให้เซิร์ฟเวอร์ "มีชีวิต" บนบรรทัดซีเรียลได้ในไม่กี่วินาที แน่นอนว่าเมื่อจำเป็นต้องใช้โมดูลจริงฉันก็ต้องจ่ายราคา (หมายเหตุ: สิ่งนี้สามารถบรรเทาได้ด้วยการวางไข่ของงานพื้นหลังimportในเวลาว่าง)