מודול Ast של Python: פענוח מניפולציה של עץ תחביר מופשט

מודול ast של Python מספק דרך עוצמתית ליצור אינטראקציה עם עץ התחביר המופשט (AST) של קוד Python. AST הוא ייצוג עץ של המבנה התחבירי של קוד המקור, מה שמאפשר לנתח, לשנות ואפילו ליצור קוד Python באופן תוכנתי. זה פותח את הדלת ליישומים שונים, כולל כלי ניתוח קוד, שיפור קוד אוטומטי, ניתוח סטטי ואפילו הרחבות שפה מותאמות אישית. מאמר זה ידריך אותך ביסודות של מודול ast, ויספק דוגמאות מעשיות ותובנות לגבי היכולות שלו.

מהו עץ תחביר מופשט (AST)?

לפני שנצלול למודול ast, בואו נבין מהו עץ תחביר מופשט. כאשר מתורגמן Python מבצע את הקוד שלך, השלב הראשון הוא לנתח את הקוד לתוך AST. מבנה עץ זה מייצג את האלמנטים התחביריים של הקוד, כגון פונקציות, מחלקות, לולאות, ביטויים ואופרטורים, יחד עם הקשרים שלהם. ה-AST משליך פרטים לא רלוונטיים כמו רווחים והערות, ומתמקד במידע המבני המהותי. על ידי ייצוג קוד בצורה זו, תוכניות יכולות לנתח ולטפל בקוד עצמו, דבר שימושי ביותר במצבים רבים.

תחילת העבודה עם מודול ast

מודול ast הוא חלק מהספרייה הסטנדרטית של Python, כך שאינך צריך להתקין חבילות נוספות. פשוט יבא אותו כדי להתחיל להשתמש בו:

            import ast
            

              
                Copy
              
            
          

פונקציית הליבה של מודול ast היא ast.parse(), שלוקחת מחרוזת של קוד Python כקלט ומחזירה אובייקט AST.

            code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)
print(ast_tree)
            

              
                Copy
              
            
          

זה יפיק משהו כמו: <_ast.Module object at 0x...>. למרות שהפלט הזה לא אינפורמטיבי במיוחד, הוא מצביע על כך שהקוד נותח בהצלחה לתוך AST. אובייקט ast_tree מכיל כעת את המבנה כולו של הקוד המנותח.

חקירת ה-AST

כדי להבין את המבנה של ה-AST, אנו יכולים להשתמש בפונקציה ast.dump(). פונקציה זו עוברת באופן רקורסיבי את העץ ומדפיסה ייצוג מפורט של כל צומת.

            code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)
print(ast.dump(ast_tree, indent=4))
            

              
                Copy
              
            
          

הפלט יהיה:

            Module(
    body=[
        FunctionDef(
            name='add',
            args=arguments(
                posonlyargs=[],
                args=[
                    arg(arg='x', annotation=None, type_comment=None),
                    arg(arg='y', annotation=None, type_comment=None)
                ],
                kwonlyargs=[],
                kw_defaults=[],
                defaults=[]
            ),
            body=[
                Return(
                    value=BinOp(
                        left=Name(id='x', ctx=Load()),
                        op=Add(),
                        right=Name(id='y', ctx=Load())
                    )
                )
            ],
            decorator_list=[],
            returns=None,
            type_comment=None
        )
    ],
    type_ignores=[]
)
            

              
                Copy
              
            
          

פלט זה מציג את המבנה ההיררכי של הקוד. בואו נפרק אותו:

• Module: צומת השורש המייצג את המודול כולו.
• body: רשימה של הצהרות בתוך המודול.
• FunctionDef: מייצג הגדרת פונקציה. התכונות שלו כוללות:
• name: שם הפונקציה ('add').
• args: הארגומנטים של הפונקציה.
• arguments: מכיל מידע על הארגומנטים של הפונקציה.
• arg: מייצג ארגומנט בודד (לדוגמה, 'x', 'y').
• body: גוף הפונקציה (רשימה של הצהרות).
• Return: מייצג הצהרת החזרה.
• value: הערך שמוחזר.
• BinOp: מייצג פעולה בינארית (לדוגמה, x + y).
• left: האופרנד השמאלי (לדוגמה, 'x').
• op: האופרטור (לדוגמה, 'Add').
• right: האופרנד הימני (לדוגמה, 'y').

מעבר על ה-AST

מודול ast מספק את המחלקה ast.NodeVisitor כדי לעבור על ה-AST. על ידי ירושה ממחלקה ast.NodeVisitor ודריסת השיטות שלה, אתה יכול לעבד סוגי צמתים ספציפיים כאשר הם נתקלים במהלך המעבר. זה שימושי לניתוח מבנה קוד, זיהוי דפוסים ספציפיים או חילוץ מידע.

            import ast

class FunctionNameExtractor(ast.NodeVisitor):
    def __init__(self):
        self.function_names = []

    def visit_FunctionDef(self, node):
        self.function_names.append(node.name)

code = """
def add(x, y):
    return x + y

def subtract(x, y):
    return x - y
"""

ast_tree = ast.parse(code)

extractor = FunctionNameExtractor()
extractor.visit(ast_tree)

print(extractor.function_names)  # Output: ['add', 'subtract']
            

              
                Copy
              
            
          

בדוגמה זו, FunctionNameExtractor יורשת מ-ast.NodeVisitor ודוחפת את השיטה visit_FunctionDef. שיטה זו נקראת עבור כל צומת הגדרת פונקציה ב-AST. השיטה מוסיפה את שם הפונקציה לרשימת function_names. השיטה visit() יוזמת את המעבר של ה-AST.

דוגמה: מציאת כל הקצאות המשתנים

            import ast

class VariableAssignmentFinder(ast.NodeVisitor):
    def __init__(self):
        self.assignments = []

    def visit_Assign(self, node):
        for target in node.targets:
            if isinstance(target, ast.Name):
                self.assignments.append(target.id)

code = """
x = 10
y = x + 5
message = "hello"
"""

ast_tree = ast.parse(code)

finder = VariableAssignmentFinder()
finder.visit(ast_tree)

print(finder.assignments)  # Output: ['x', 'y', 'message']
            

              
                Copy
              
            
          

דוגמה זו מוצאת את כל הקצאות המשתנים בקוד. השיטה visit_Assign נקראת עבור כל הצהרת הקצאה. הוא חוזר על המטרות של ההקצאה, ואם מטרה היא שם פשוט (ast.Name), הוא מוסיף את השם לרשימת assignments.

שינוי ה-AST

מודול ast גם מאפשר לך לשנות את ה-AST. אתה יכול לשנות צמתים קיימים, להוסיף צמתים חדשים או להסיר צמתים לחלוטין. כדי לשנות את ה-AST, אתה משתמש במחלקה ast.NodeTransformer. בדומה ל-ast.NodeVisitor, אתה יורש ממחלקה ast.NodeTransformer ודורס את השיטות שלה כדי לשנות סוגי צמתים ספציפיים. ההבדל העיקרי הוא ששיטות ast.NodeTransformer צריכות להחזיר את הצומת ששונה (או צומת חדש כדי להחליף אותו). אם שיטה מחזירה None, הצומת מוסר מה-AST.

לאחר שינוי ה-AST, עליך לקמפל אותו בחזרה לקוד Python שניתן להפעיל באמצעות הפונקציה compile().

            import ast

class AddOneTransformer(ast.NodeTransformer):
    def visit_Num(self, node):
        return ast.Num(n=node.n + 1)

code = """
x = 10
y = 20
"""

ast_tree = ast.parse(code)

transformer = AddOneTransformer()
new_ast_tree = transformer.visit(ast_tree)

new_code = compile(new_ast_tree, '', 'exec')

# Execute the modified code
exec(new_code)

print(x)  # Output: 11
print(y)  # Output: 21
            

              
                Copy
              
            
          

בדוגמה זו, AddOneTransformer יורשת מ-ast.NodeTransformer ודוחפת את השיטה visit_Num. שיטה זו נקראת עבור כל צומת מילולי מספרי (ast.Num). השיטה יוצרת צומת ast.Num חדש עם הערך מוגדל ב-1. השיטה visit() מחזירה את ה-AST ששונה.

הפונקציה compile() לוקחת את ה-AST ששונה, שם קובץ (<string> במקרה זה, המציין שהקוד מגיע ממחרוזת) ומצב ביצוע ('exec' להפעלת בלוק קוד). הוא מחזיר אובייקט קוד שניתן להפעיל באמצעות הפונקציה exec().

דוגמה: החלפת שם משתנה

            import ast

class VariableNameReplacer(ast.NodeTransformer):
    def __init__(self, old_name, new_name):
        self.old_name = old_name
        self.new_name = new_name

    def visit_Name(self, node):
        if node.id == self.old_name:
            return ast.Name(id=self.new_name, ctx=node.ctx)
        return node

code = """
def multiply_by_two(number):
    return number * 2

result = multiply_by_two(5)
print(result)
"""

ast_tree = ast.parse(code)

replacer = VariableNameReplacer('number', 'num')
new_ast_tree = replacer.visit(ast_tree)

new_code = compile(new_ast_tree, '', 'exec')

# Execute the modified code
exec(new_code)

            

              
                Copy
              
            
          

דוגמה זו מחליפה את כל המופעים של שם המשתנה 'number' ב-'num'. VariableNameReplacer לוקח את השמות הישנים והחדשים כארגומנטים. השיטה visit_Name נקראת עבור כל צומת שם. אם המזהה של הצומת תואם לשם הישן, הוא יוצר צומת ast.Name חדש עם השם החדש ואותו הקשר (node.ctx). ההקשר מציין כיצד השם משמש (לדוגמה, טעינה, אחסון).

יצירת קוד מ-AST

אמנם compile() מאפשר לך להפעיל קוד מ-AST, אך הוא לא מספק דרך לקבל את הקוד כמחרוזת. כדי ליצור קוד Python מ-AST, אתה יכול להשתמש בספרייה astunparse. ספרייה זו אינה חלק מהספרייה הסטנדרטית, ולכן עליך להתקין אותה תחילה:

            pip install astunparse
            

              
                Copy
              
            
          

לאחר מכן, אתה יכול להשתמש בפונקציה astunparse.unparse() כדי ליצור קוד מ-AST.

            import ast
import astunparse

code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)

generated_code = astunparse.unparse(ast_tree)

print(generated_code)
            

              
                Copy
              
            
          

הפלט יהיה:

            def add(x, y):
    return (x + y)

            

              
                Copy
              
            
          

שים לב: הסוגריים סביב (x + y) מתווספים על ידי astunparse כדי להבטיח סדר קדימויות נכון של אופרטורים. ייתכן שסוגריים אלה אינם הכרחיים לחלוטין, אך הם מבטיחים את נכונות הקוד.

דוגמה: יצירת מחלקה פשוטה

            import ast
import astunparse

class_name = 'MyClass'
method_name = 'my_method'

# Create the class definition node
class_def = ast.ClassDef(
    name=class_name,
    bases=[],
    keywords=[],
    body=[
        ast.FunctionDef(
            name=method_name,
            args=ast.arguments(
                posonlyargs=[],
                args=[],
                kwonlyargs=[],
                kw_defaults=[],
                defaults=[]
            ),
            body=[
                ast.Pass()
            ],
            decorator_list=[],
            returns=None,
            type_comment=None
        )
    ],
    decorator_list=[]
)

# Create the module node containing the class definition
module = ast.Module(body=[class_def], type_ignores=[])

# Generate the code
code = astunparse.unparse(module)

print(code)
            

              
                Copy
              
            
          

דוגמה זו יוצרת את קוד ה-Python הבא:

            class MyClass:

    def my_method():
        pass

            

              
                Copy
              
            
          

זה מדגים כיצד לבנות AST מאפס ולאחר מכן ליצור ממנו קוד. גישה זו היא עוצמתית עבור כלי יצירת קוד ומטה-תכנות.

יישומים מעשיים של מודול ast

למודול ast יש יישומים מעשיים רבים, כולל:

• ניתוח קוד: ניתוח קוד עבור הפרות סגנון, נקודות תורפה אבטחה או צווארי בקבוק ביצועים. לדוגמה, אתה יכול לכתוב כלי לאכיפת תקני קידוד על פני פרויקט גדול.
• שיפור קוד אוטומטי: אוטומציה של משימות כמו שינוי שם משתנים, חילוץ שיטות או המרת קוד לשימוש בתכונות שפה חדשות יותר. כלים כמו `rope` ממנפים ASTs עבור יכולות שיפור קוד חזקות.
• ניתוח סטטי: זיהוי שגיאות או באגים פוטנציאליים בקוד מבלי להפעיל אותו בפועל. כלים כמו `pylint` ו-`flake8` משתמשים בניתוח AST כדי לזהות בעיות.
• יצירת קוד: יצירת קוד אוטומטית על סמך תבניות או מפרטים. זה שימושי ליצירת קוד חוזר או יצירת קוד עבור פלטפורמות שונות.
• הרחבות שפה: יצירת הרחבות שפה מותאמות אישית או שפות ספציפיות לתחום (DSLs) על ידי המרת קוד Python לייצוגים שונים.
• ביקורת אבטחה: ניתוח קוד עבור מבנים או נקודות תורפה שעלולות להזיק. זה יכול לשמש כדי לזהות שיטות קידוד לא מאובטחות.

דוגמה: אכיפת סגנון קידוד

נניח שאתה רוצה לאכוף שכל שמות הפונקציות בפרויקט שלך יפעלו לפי מוסכמת snake_case (לדוגמה, my_function במקום myFunction). אתה יכול להשתמש במודול ast כדי לבדוק אם יש הפרות.

            import ast
import re

class SnakeCaseChecker(ast.NodeVisitor):
    def __init__(self):
        self.errors = []

    def visit_FunctionDef(self, node):
        if not re.match(r'^[a-z]+(_[a-z]+)*$', node.name):
            self.errors.append(f"Function name '{node.name}' does not follow snake_case convention")

    def check_code(self, code):
        ast_tree = ast.parse(code)
        self.visit(ast_tree)
        return self.errors

# Example usage
code = """
def myFunction(x):
    return x * 2

def calculate_area(width, height):
    return width * height
"""

checker = SnakeCaseChecker()
errors = checker.check_code(code)

if errors:
    for error in errors:
        print(error)
else:
    print("No style violations found")
            

              
                Copy
              
            
          

קוד זה מגדיר מחלקה SnakeCaseChecker שיורשת מ-ast.NodeVisitor. השיטה visit_FunctionDef בודקת אם שם הפונקציה תואם לביטוי הרגולרי snake_case. אם לא, הוא מוסיף הודעת שגיאה לרשימת errors. השיטה check_code מנתחת את הקוד, עוברת על ה-AST ומחזירה את רשימת השגיאות.

שיטות עבודה מומלצות בעבודה עם מודול ast

• הבנת מבנה ה-AST: לפני שתנסה לטפל ב-AST, הקדש זמן להבנת המבנה שלו באמצעות ast.dump(). זה יעזור לך לזהות את הצמתים שאתה צריך לעבוד איתם.
• השתמש ב-ast.NodeVisitor וב-ast.NodeTransformer: מחלקות אלה מספקות דרך נוחה לעבור ולשנות את ה-AST מבלי שתצטרך לנווט בעץ באופן ידני.
• בדוק ביסודיות: בעת שינוי ה-AST, בדוק את הקוד שלך ביסודיות כדי להבטיח שהשינויים נכונים ואינם גורמים לשגיאות כלשהן.
• שקול astunparse ליצירת קוד: אמנם compile() שימושי להפעלת קוד ששונה, astunparse מספק דרך ליצור קוד Python קריא מ-AST.
• השתמש ברמזי סוג: רמזי סוג יכולים לשפר משמעותית את הקריאות והתחזוקה של הקוד שלך, במיוחד בעבודה עם מבני AST מורכבים.
• תעד את הקוד שלך: בעת יצירת מבקרים או טרנספורמטורים מותאמים אישית של AST, תעד את הקוד שלך בבירור כדי להסביר את המטרה של כל שיטה ואת השינויים שהיא מבצעת ב-AST.

אתגרים ושיקולים

• מורכבות: עבודה עם ASTs יכולה להיות מורכבת, במיוחד עבור בסיסי קוד גדולים יותר. הבנת סוגי הצמתים השונים והקשרים שלהם יכולה להיות מאתגרת.
• תחזוקה: מבני AST יכולים להשתנות בין גרסאות Python. הקפד לבדוק את הקוד שלך עם גרסאות Python שונות כדי להבטיח תאימות.
• ביצועים: מעבר ושינוי של ASTs גדולים יכולים להיות איטיים. שקול לייעל את הקוד שלך כדי לשפר את הביצועים. שמירת צמתים שנמצאים בשימוש תדיר במטמון או שימוש באלגוריתמים יעילים יותר יכולים לעזור.
• טיפול בשגיאות: טפל בשגיאות בחן בעת ניתוח או טיפול ב-AST. ספק הודעות שגיאה אינפורמטיביות למשתמש.
• אבטחה: היזהר בעת הפעלת קוד שנוצר מ-AST, במיוחד אם ה-AST מבוסס על קלט משתמש. חטא את הקלט כדי למנוע התקפות הזרקת קוד.

מסקנה

מודול ast של Python מספק דרך עוצמתית וגמישה ליצור אינטראקציה עם עץ התחביר המופשט של קוד Python. על ידי הבנת מבנה ה-AST ושימוש במחלקות ast.NodeVisitor ו-ast.NodeTransformer, אתה יכול לנתח, לשנות וליצור קוד Python באופן תוכנתי. זה פותח את הדלת למגוון רחב של יישומים, מכלי ניתוח קוד ועד לשיפור קוד אוטומטי ואפילו הרחבות שפה מותאמות אישית. אמנם עבודה עם ASTs יכולה להיות מורכבת, אך היתרונות של היכולת לטפל בקוד באופן תוכנתי הם משמעותיים. אמץ את העוצמה של מודול ast כדי לפתוח אפשרויות חדשות בפרויקטי Python שלך.