Python Ast Module: การจัดการ Abstract Syntax Tree อย่างละเอียด

โมดูล ast ของ Python มอบวิธีที่มีประสิทธิภาพในการโต้ตอบกับ abstract syntax tree (AST) ของโค้ด Python AST คือโครงสร้างแบบต้นไม้ที่แสดงโครงสร้างทางไวยากรณ์ของซอร์สโค้ด ทำให้สามารถวิเคราะห์ แก้ไข และแม้กระทั่งสร้างโค้ด Python ด้วยโปรแกรมได้ สิ่งนี้เปิดประตูสู่แอปพลิเคชันที่หลากหลาย รวมถึงเครื่องมือวิเคราะห์โค้ด การปรับปรุงโค้ดอัตโนมัติ การวิเคราะห์แบบคงที่ และแม้กระทั่งส่วนขยายภาษาแบบกำหนดเอง บทความนี้จะแนะนำคุณเกี่ยวกับพื้นฐานของโมดูล ast พร้อมตัวอย่างที่ใช้งานได้จริงและข้อมูลเชิงลึกเกี่ยวกับความสามารถของมัน

Abstract Syntax Tree (AST) คืออะไร?

ก่อนที่จะเจาะลึกโมดูล ast มาทำความเข้าใจกันก่อนว่า Abstract Syntax Tree คืออะไร เมื่อล่าม 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: แทนคำสั่ง 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 จากศูนย์ แล้วจึงสร้างโค้ดจากมัน วิธีการนี้มีประสิทธิภาพสำหรับเครื่องมือสร้างโค้ดและ metaprogramming

การใช้งานจริงของโมดูล ast

โมดูล ast มีการใช้งานจริงมากมาย รวมถึง:

• การวิเคราะห์โค้ด: วิเคราะห์โค้ดเพื่อหาการละเมิดสไตล์ ช่องโหว่ด้านความปลอดภัย หรือคอขวดด้านประสิทธิภาพ ตัวอย่างเช่น คุณสามารถเขียนเครื่องมือเพื่อบังคับใช้มาตรฐานการเขียนโค้ดในโปรเจกต์ขนาดใหญ่
• การปรับปรุงโค้ดอัตโนมัติ: ทำให้งานต่างๆ เช่น การเปลี่ยนชื่อตัวแปร การแยกเมธอด หรือการแปลงโค้ดเพื่อใช้คุณสมบัติภาษาที่ใหม่กว่าเป็นอัตโนมัติ เครื่องมือเช่น `rope` ใช้ AST เพื่อความสามารถในการปรับปรุงโค้ดที่มีประสิทธิภาพ
• การวิเคราะห์แบบคงที่: ระบุข้อผิดพลาดหรือบั๊กที่อาจเกิดขึ้นในโค้ดโดยไม่ต้องรันจริงๆ เครื่องมือเช่น `pylint` และ `flake8` ใช้การวิเคราะห์ AST เพื่อตรวจหาปัญหา
• การสร้างโค้ด: สร้างโค้ดโดยอัตโนมัติตามเทมเพลตหรือข้อกำหนด สิ่งนี้มีประโยชน์สำหรับการสร้างโค้ดซ้ำๆ หรือการสร้างโค้ดสำหรับแพลตฟอร์มต่างๆ
• ส่วนขยายภาษา: สร้างส่วนขยายภาษาแบบกำหนดเองหรือภาษาเฉพาะโดเมน (DSL) โดยการแปลงโค้ด 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
• ใช้ Type Hints: Type hints สามารถปรับปรุงความสามารถในการอ่านและความสามารถในการบำรุงรักษาโค้ดของคุณได้อย่างมาก โดยเฉพาะอย่างยิ่งเมื่อทำงานกับโครงสร้าง AST ที่ซับซ้อน
• จัดทำเอกสารประกอบโค้ดของคุณ: เมื่อสร้างเครื่องมือเยี่ยมชมหรือตัวแปลง AST แบบกำหนดเอง ให้จัดทำเอกสารประกอบโค้ดของคุณอย่างชัดเจนเพื่ออธิบายวัตถุประสงค์ของแต่ละเมธอดและการเปลี่ยนแปลงที่ทำให้กับ AST

ความท้าทายและข้อควรพิจารณา

• ความซับซ้อน: การทำงานกับ AST อาจซับซ้อน โดยเฉพาะอย่างยิ่งสำหรับฐานโค้ดขนาดใหญ่ การทำความเข้าใจประเภทโหนดต่างๆ และความสัมพันธ์ของพวกมันอาจเป็นเรื่องท้าทาย
• การบำรุงรักษา: โครงสร้าง AST อาจเปลี่ยนแปลงไปตามเวอร์ชันของ Python ตรวจสอบให้แน่ใจว่าคุณทดสอบโค้ดของคุณกับ Python เวอร์ชันต่างๆ เพื่อรับประกันความเข้ากันได้
• ประสิทธิภาพ: การท่องและแก้ไข AST ขนาดใหญ่อาจใช้เวลานาน พิจารณาเพิ่มประสิทธิภาพโค้ดของคุณเพื่อปรับปรุงประสิทธิภาพ การแคชโหนดที่เข้าถึงบ่อยหรือใช้อัลกอริทึมที่มีประสิทธิภาพมากขึ้นสามารถช่วยได้
• การจัดการข้อผิดพลาด: จัดการข้อผิดพลาดอย่างเหมาะสมเมื่อแยกวิเคราะห์หรือจัดการ AST ให้ข้อความแสดงข้อผิดพลาดที่ให้ข้อมูลแก่ผู้ใช้
• ความปลอดภัย: ระมัดระวังเมื่อประมวลผลโค้ดที่สร้างจาก AST โดยเฉพาะอย่างยิ่งหาก AST นั้นอิงตามอินพุตของผู้ใช้ ทำความสะอาดอินพุตเพื่อป้องกันการโจมตีแบบ code injection

สรุป

โมดูล ast ของ Python มอบวิธีที่มีประสิทธิภาพและยืดหยุ่นในการโต้ตอบกับ abstract syntax tree ของโค้ด Python โดยการทำความเข้าใจโครงสร้าง AST และใช้คลาส ast.NodeVisitor และ ast.NodeTransformer คุณสามารถวิเคราะห์ แก้ไข และสร้างโค้ด Python ด้วยโปรแกรมได้ สิ่งนี้เปิดประตูสู่แอปพลิเคชันที่หลากหลาย ตั้งแต่เครื่องมือวิเคราะห์โค้ดไปจนถึงการปรับปรุงโค้ดอัตโนมัติ และแม้กระทั่งส่วนขยายภาษาแบบกำหนดเอง แม้ว่าการทำงานกับ AST อาจซับซ้อน แต่ประโยชน์ของการสามารถจัดการโค้ดด้วยโปรแกรมได้นั้นมีความสำคัญ โอบรับพลังของโมดูล ast เพื่อปลดล็อกความเป็นไปได้ใหม่ๆ ในโปรเจกต์ Python ของคุณ