ฉันจะรับซอร์สโค้ดของฟังก์ชัน Python ได้อย่างไร

สมมติว่าฉันมีฟังก์ชัน Python ตามที่กำหนดไว้ด้านล่าง:

def foo(arg1,arg2):
    #do something with args
    a = arg1 + arg2
    return a

foo.func_nameฉันจะได้รับชื่อของฟังก์ชั่นที่ใช้ ฉันจะรับซอร์สโค้ดของโปรแกรมโดยวิธีตามที่ฉันพิมพ์ด้านบนได้อย่างไร

หากฟังก์ชั่นนั้นมาจากไฟล์ต้นฉบับที่มีอยู่ในระบบไฟล์นั่นinspect.getsource(foo)อาจเป็นประโยชน์:

หากfooถูกกำหนดเป็น:

def foo(arg1,arg2):         
    #do something with args 
    a = arg1 + arg2         
    return a  

แล้ว:

import inspect
lines = inspect.getsource(foo)
print(lines)

ผลตอบแทน:

def foo(arg1,arg2):         
    #do something with args 
    a = arg1 + arg2         
    return a                

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

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

dis เป็นเพื่อนของคุณถ้ารหัสแหล่งที่มาไม่สามารถใช้ได้:

>>> import dis
>>> def foo(arg1,arg2):
...     #do something with args
...     a = arg1 + arg2
...     return a
...
>>> dis.dis(foo)
  3           0 LOAD_FAST                0 (arg1)
              3 LOAD_FAST                1 (arg2)
              6 BINARY_ADD
              7 STORE_FAST               2 (a)

  4          10 LOAD_FAST                2 (a)
             13 RETURN_VALUE

หากคุณใช้ IPython คุณต้องพิมพ์ "foo ??"

In [19]: foo??
Signature: foo(arg1, arg2)
Source:
def foo(arg1,arg2):
    #do something with args
    a = arg1 + arg2
    return a

File:      ~/Desktop/<ipython-input-18-3174e3126506>
Type:      function

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

>>> from dill.source import getsource
>>> 
>>> def add(x,y):
...   return x+y
... 
>>> squared = lambda x:x**2
>>> 
>>> print getsource(add)
def add(x,y):
  return x+y

>>> print getsource(squared)
squared = lambda x:x**2

>>> 
>>> class Foo(object):
...   def bar(self, x):
...     return x*x+x
... 
>>> f = Foo()
>>> 
>>> print getsource(f.bar)
def bar(self, x):
    return x*x+x

>>> 

หากต้องการขยายคำตอบของ runeh:

>>> def foo(a):
...    x = 2
...    return x + a

>>> import inspect

>>> inspect.getsource(foo)
u'def foo(a):\n    x = 2\n    return x + a\n'

print inspect.getsource(foo)
def foo(a):
   x = 2
   return x + a

แก้ไข: ในฐานะที่เป็นแหลมออกโดย @ 0sh ตัวอย่างนี้ทำงานโดยใช้แต่ไม่ธรรมดาipython pythonอย่างไรก็ตามควรจะใช้ได้ทั้งคู่เมื่อนำเข้ารหัสจากไฟล์ต้นฉบับ

คุณสามารถใช้inspectโมดูลเพื่อรับซอร์สโค้ดแบบเต็มสำหรับสิ่งนั้น คุณต้องใช้getsource()วิธีการนั้นจากinspectโมดูล ตัวอย่างเช่น:

import inspect

def get_my_code():
    x = "abcd"
    return x

print(inspect.getsource(get_my_code))

คุณสามารถตรวจสอบตัวเลือกเพิ่มเติมได้จากลิงค์ด้านล่าง รับรหัสหลามของคุณ

เนื่องจากโพสต์นี้ถูกทำเครื่องหมายว่าซ้ำกับโพสต์อื่นนี้ฉันตอบที่นี่สำหรับเคส "แลมบ์ดา" แม้ว่า OP จะไม่เกี่ยวกับแลมบ์ดา

ดังนั้นสำหรับฟังก์ชั่นแลมบ์ดาที่ไม่ได้กำหนดไว้ในสายของตนเอง: นอกเหนือจากคำตอบของmarko.ristinคุณอาจต้องการใช้mini-lambdaหรือใช้SymPyตามที่แนะนำในคำตอบนี้

• mini-lambda มีน้ำหนักเบาและรองรับการทำงานทุกประเภท แต่ใช้ได้กับตัวแปรเดียวเท่านั้น
• SymPyมีน้ำหนักมากขึ้น แต่มีความพร้อมมากขึ้นในการดำเนินการทางคณิตศาสตร์ / แคลคูลัส โดยเฉพาะอย่างยิ่งสามารถทำให้การแสดงออกของคุณง่ายขึ้น นอกจากนี้ยังรองรับตัวแปรหลายตัวในนิพจน์เดียวกัน

นี่คือวิธีที่คุณสามารถทำได้โดยใช้mini-lambda:

from mini_lambda import x, is_mini_lambda_expr
import inspect

def get_source_code_str(f):
    if is_mini_lambda_expr(f):
        return f.to_string()
    else:
        return inspect.getsource(f)

# test it

def foo(arg1, arg2):
    # do something with args
    a = arg1 + arg2
    return a

print(get_source_code_str(foo))
print(get_source_code_str(x ** 2))

มันให้ผลตอบแทนที่ถูกต้อง

def foo(arg1, arg2):
    # do something with args
    a = arg1 + arg2
    return a

x ** 2

ดูmini-lambda เอกสารประกอบสำหรับรายละเอียด ฉันเป็นผู้แต่งโดยวิธี;)

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

ตัวอย่างเช่นพิจารณาไฟล์test.py:

import inspect

def main():
    x, f = 3, lambda a: a + 1
    print(inspect.getsource(f))

if __name__ == "__main__":
    main()

การดำเนินการจะช่วยให้คุณ (ใจเยื้อง!):

    x, f = 3, lambda a: a + 1

ในการดึงซอร์สโค้ดของแลมบ์ดาทางออกที่ดีที่สุดของคุณคือการแยกวิเคราะห์ไฟล์ต้นฉบับทั้งหมด (โดยใช้f.__code__.co_filename) และจับคู่โหนดแลมบ์ดา AST ด้วยหมายเลขบรรทัดและบริบท

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

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

เช่น

funcstring = 'lambda x: x> 5'
func = eval(funcstring)

จากนั้นเลือกที่จะแนบรหัสต้นฉบับเข้ากับฟังก์ชัน:

func.source = funcstring

เพื่อสรุป:

import inspect
print( "".join(inspect.getsourcelines(foo)[0]))

ฉันเชื่อว่าชื่อตัวแปรไม่ได้ถูกจัดเก็บไว้ในไฟล์ pyc / pyd / pyo ดังนั้นคุณจึงไม่สามารถเรียกรหัสบรรทัดที่แน่นอนได้หากคุณไม่มีไฟล์ต้นฉบับ