برنامه نویسی متا در پایتون: تولید کد پویا و اصلاح در زمان اجرا

برنامه نویسی متا یک پارادایم برنامه نویسی قدرتمند است که در آن کد، کد دیگری را دستکاری می کند. در پایتون، این امکان را به شما می دهد تا به طور پویا کلاس ها، توابع و ماژول ها را در زمان اجرا ایجاد، اصلاح یا بررسی کنید. این امر طیف گسترده ای از امکانات را برای سفارشی سازی پیشرفته، تولید کد و طراحی نرم افزار انعطاف پذیر باز می کند.

برنامه نویسی متا چیست؟

برنامه نویسی متا را می توان به عنوان نوشتن کدی تعریف کرد که کد دیگری (یا خود) را به عنوان داده دستکاری می کند. این به شما امکان می دهد از ساختار استاتیک معمولی برنامه های خود فراتر رفته و کدی ایجاد کنید که بر اساس نیازها یا شرایط خاص سازگار و تکامل می یابد. این انعطاف پذیری به ویژه در سیستم ها، چارچوب ها و کتابخانه های پیچیده مفید است.

به این شکل به آن فکر کنید: به جای اینکه فقط کدی برای حل یک مشکل خاص بنویسید، کدی می نویسید که کدی می نویسد تا مشکلات را حل کند. این یک لایه انتزاعی را معرفی می کند که می تواند منجر به راه حل های قابل نگهداری و سازگارتر شود.

تکنیک های کلیدی در برنامه نویسی متا پایتون

پایتون چندین ویژگی را ارائه می دهد که برنامه نویسی متا را فعال می کند. در اینجا برخی از مهمترین تکنیک ها آورده شده است:

• فراداده ها: اینها کلاس هایی هستند که نحوه ایجاد کلاس های دیگر را تعریف می کنند.
• دکوراتورها: اینها راهی برای اصلاح یا بهبود توابع یا کلاس ها ارائه می دهند.
• درون نگری: این به شما امکان می دهد خواص و روش های اشیاء را در زمان اجرا بررسی کنید.
• ویژگی های پویا: افزودن یا اصلاح ویژگی ها به اشیاء در لحظه.
• تولید کد: ایجاد برنامه ای کد منبع.
• وصله میمون: اصلاح یا گسترش کد در زمان اجرا.

فراداده ها: کارخانه کلاس ها

فراداده ها به جرات قدرتمندترین و پیچیده ترین جنبه برنامه نویسی متا پایتون هستند. آنها "کلاس های کلاس ها" هستند - آنها رفتار خود کلاس ها را تعریف می کنند. وقتی کلاسی را تعریف می کنید، فراداده مسئول ایجاد شی کلاس است.

درک مبانی

به طور پیش فرض، پایتون از فراداده داخلی type استفاده می کند. می توانید فراداده های خود را با ارث بردن از type و لغو روش های آن ایجاد کنید. مهمترین روش برای لغو __new__ است که مسئول ایجاد شی کلاس است.

بیایید یک مثال ساده را بررسی کنیم:

            class MyMeta(type):
 def __new__(cls, name, bases, attrs):
 attrs['attribute_added_by_metaclass'] = 'Hello from MyMeta!'
 return super().__new__(cls, name, bases, attrs)

class MyClass(metaclass=MyMeta):
 pass

obj = MyClass()
print(obj.attribute_added_by_metaclass)  # Output: Hello from MyMeta!

            

              
                Copy
              
            
          

در این مثال، MyMeta یک فراداده است که ویژگی ای به نام attribute_added_by_metaclass را به هر کلاسی که از آن استفاده می کند اضافه می کند. هنگامی که MyClass ایجاد می شود، متد __new__ در MyMeta فراخوانی می شود و قبل از نهایی شدن شی کلاس، ویژگی را اضافه می کند.

موارد استفاده برای فراداده ها

فراداده ها در موقعیت های مختلفی استفاده می شوند، از جمله:

• اجرای استانداردهای کدنویسی: می توانید از فراداده برای اطمینان از اینکه همه کلاس ها در یک سیستم از قراردادهای نامگذاری، انواع ویژگی یا امضای متد خاصی پیروی می کنند، استفاده کنید.
• ثبت خودکار: در سیستم های افزونه، یک فراداده می تواند به طور خودکار کلاس های جدید را در یک رجیستری مرکزی ثبت کند.
• نگاشت شیء-رابطه ای (ORM): فراداده ها در ORM ها برای نگاشت کلاس ها به جداول پایگاه داده و ویژگی ها به ستون ها استفاده می شوند.
• ایجاد تک نسخه ها: اطمینان از اینکه فقط یک نمونه از یک کلاس می تواند ایجاد شود.

مثال: اجرای انواع ویژگی

سناریویی را در نظر بگیرید که می خواهید اطمینان حاصل کنید که همه ویژگی ها در یک کلاس دارای یک نوع خاص هستند، مثلاً یک رشته. می توانید این کار را با یک فراداده انجام دهید:

            class StringAttributeMeta(type):
 def __new__(cls, name, bases, attrs):
 for attr_name, attr_value in attrs.items():
 if not attr_name.startswith('__') and not isinstance(attr_value, str):
 raise TypeError(f"Attribute '{attr_name}' must be a string")
 return super().__new__(cls, name, bases, attrs)

class MyClass(metaclass=StringAttributeMeta):
 name = "John Doe"
 age = 30 # This will raise a TypeError

            

              
                Copy
              
            
          

در این حالت، اگر سعی کنید ویژگی ای را تعریف کنید که رشته نیست، فراداده در هنگام ایجاد کلاس یک TypeError ایجاد می کند و از تعریف نادرست کلاس جلوگیری می کند.

دکوراتورها: بهبود توابع و کلاس ها

دکوراتورها روشی از نظر نحوی زیبا برای اصلاح یا بهبود توابع یا کلاس ها ارائه می دهند. آنها اغلب برای کارهایی مانند ثبت، زمان بندی، احراز هویت و اعتبارسنجی استفاده می شوند.

دکوراتورهای تابع

دکوراتور تابع تابعی است که تابع دیگری را به عنوان ورودی می گیرد، آن را به نحوی تغییر می دهد و تابع اصلاح شده را برمی گرداند. از نحو @ برای اعمال دکوراتور به یک تابع استفاده می شود.

در اینجا یک مثال ساده از دکوراتور وجود دارد که زمان اجرای یک تابع را ثبت می کند:

            import time

def timer(func):
 def wrapper(*args, **kwargs):
 start_time = time.time()
 result = func(*args, **kwargs)
 end_time = time.time()
 print(f"Function '{func.__name__}' took {end_time - start_time:.4f} seconds")
 return result
 return wrapper

@timer
def my_function():
 time.sleep(1)

my_function()

            

              
                Copy
              
            
          

در این مثال، دکوراتور timer تابع my_function را می پیچد. هنگامی که my_function فراخوانی می شود، تابع wrapper اجرا می شود، که زمان اجرا را اندازه گیری می کند و آن را در کنسول چاپ می کند.

دکوراتورهای کلاس

دکوراتورهای کلاس به طور مشابه با دکوراتورهای تابع کار می کنند، اما به جای توابع، کلاس ها را تغییر می دهند. از آنها می توان برای افزودن ویژگی ها، روش ها یا اصلاح موارد موجود استفاده کرد.

در اینجا یک مثال از یک دکوراتور کلاس وجود دارد که یک روش را به یک کلاس اضافه می کند:

            def add_method(method):
 def decorator(cls):
 setattr(cls, method.__name__, method)
 return cls
 return decorator

def my_new_method(self):
 print("This method was added by a decorator!")

@add_method(my_new_method)
class MyClass:
 pass

obj = MyClass()
obj.my_new_method()  # Output: This method was added by a decorator!

            

              
                Copy
              
            
          

در این مثال، دکوراتور add_method متد my_new_method را به کلاس MyClass اضافه می کند. هنگامی که یک نمونه از MyClass ایجاد می شود، روش جدید در دسترس خواهد بود.

کاربردهای عملی دکوراتورها

• ثبت: ثبت تماس های تابع، آرگومان ها و مقادیر برگشتی.
• احراز هویت: تأیید اعتبار کاربر قبل از اجرای یک تابع.
• ذخیره سازی: ذخیره نتایج فراخوانی های تابع گران قیمت برای بهبود عملکرد.
• اعتبارسنجی: اعتبارسنجی پارامترهای ورودی برای اطمینان از مطابقت آنها با معیارهای خاص.
• مجوز: بررسی مجوزهای کاربر قبل از اجازه دسترسی به یک منبع.

درون نگری: بررسی اشیاء در زمان اجرا

درون نگری توانایی بررسی خواص و روش های اشیاء در زمان اجرا است. پایتون چندین تابع و ماژول داخلی را ارائه می دهد که از درون نگری پشتیبانی می کنند، از جمله type()، dir()، getattr()، hasattr() و ماژول inspect.

استفاده از type()

تابع type() نوع یک شی را برمی گرداند.

            x = 5
print(type(x))  # Output: <class 'int'>

            

              
                Copy
              
            
          

استفاده از dir()

تابع dir() لیستی از ویژگی ها و روش های یک شی را برمی گرداند.

            class MyClass:
 def __init__(self):
 self.name = "John"

obj = MyClass()
print(dir(obj))
# Output: ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name']

            

              
                Copy
              
            
          

استفاده از getattr() و hasattr()

تابع getattr() مقدار یک ویژگی را بازیابی می کند و تابع hasattr() بررسی می کند که آیا یک شیء دارای یک ویژگی خاص است یا خیر.

            class MyClass:
 def __init__(self):
 self.name = "John"

obj = MyClass()

if hasattr(obj, 'name'):
 print(getattr(obj, 'name'))  # Output: John

if hasattr(obj, 'age'):
 print(getattr(obj, 'age'))
else:
 print("Object does not have age attribute") # Output: Object does not have age attribute

            

              
                Copy
              
            
          

استفاده از ماژول inspect

ماژول inspect انواع توابع را برای بررسی دقیق تر اشیاء ارائه می دهد، مانند دریافت کد منبع یک تابع یا کلاس، یا دریافت آرگومان های یک تابع.

            import inspect

def my_function(a, b):
 return a + b

source_code = inspect.getsource(my_function)
print(source_code)
# Output:
# def my_function(a, b):
# return a + b

signature = inspect.signature(my_function)
print(signature) # Output: (a, b)

            

              
                Copy
              
            
          

موارد استفاده برای درون نگری

• اشکال زدایی: بازرسی اشیاء برای درک وضعیت و رفتار آنها.
• تست: تأیید اینکه اشیاء دارای ویژگی ها و روش های مورد انتظار هستند.
• مستندسازی: تولید خودکار مستندات از کد.
• توسعه چارچوب: کشف و استفاده پویا از اجزاء در یک چارچوب.
• سریال سازی و غیرسریال سازی: بررسی اشیاء برای تعیین نحوه سریال سازی و غیرسریال سازی آنها.

ویژگی های پویا: افزودن انعطاف پذیری

پایتون به شما این امکان را می دهد که ویژگی ها را به اشیاء در زمان اجرا اضافه یا اصلاح کنید و انعطاف پذیری زیادی به شما می دهد. این می تواند در موقعیت هایی مفید باشد که نیاز به افزودن ویژگی ها بر اساس ورودی کاربر یا داده های خارجی دارید.

افزودن ویژگی ها

می توانید به سادگی با اختصاص دادن مقدار به نام ویژگی جدید، ویژگی ها را به یک شی اضافه کنید.

            class MyClass:
 pass

obj = MyClass()
obj.new_attribute = "This is a new attribute"

print(obj.new_attribute)  # Output: This is a new attribute

            

              
                Copy
              
            
          

اصلاح ویژگی ها

می توانید مقدار یک ویژگی موجود را با اختصاص دادن مقدار جدید به آن تغییر دهید.

            class MyClass:
 def __init__(self):
 self.name = "John"

obj = MyClass()
obj.name = "Jane"

print(obj.name)  # Output: Jane

            

              
                Copy
              
            
          

استفاده از setattr() و delattr()

تابع setattr() به شما امکان می دهد مقدار یک ویژگی را تنظیم کنید و تابع delattr() به شما امکان می دهد یک ویژگی را حذف کنید.

            class MyClass:
 def __init__(self):
 self.name = "John"

obj = MyClass()
setattr(obj, 'age', 30)
print(obj.age)  # Output: 30

delattr(obj, 'name')

if hasattr(obj, 'name'):
 print(obj.name)
else:
 print("Object does not have name attribute") # Output: Object does not have name attribute

            

              
                Copy
              
            
          

موارد استفاده برای ویژگی های پویا

• پیکربندی: بارگیری تنظیمات پیکربندی از یک فایل یا پایگاه داده و اختصاص دادن آنها به عنوان ویژگی به یک شی.
• اتصال داده: اتصال پویا داده ها از یک منبع داده به ویژگی های یک شی.
• سیستم های افزونه: افزودن ویژگی ها به یک شی بر اساس افزونه های بارگیری شده.
• نمونه سازی اولیه: افزودن و اصلاح سریع ویژگی ها در طول فرآیند توسعه.

تولید کد: خودکارسازی ایجاد کد

تولید کد شامل ایجاد برنامه ای کد منبع است. این می تواند برای تولید کد تکراری، ایجاد کد بر اساس الگوها یا انطباق کد با پلتفرم ها یا محیط های مختلف مفید باشد.

استفاده از دستکاری رشته

یک راه ساده برای تولید کد این است که از دستکاری رشته برای ایجاد کد به عنوان یک رشته استفاده کنید و سپس رشته را با استفاده از تابع exec() اجرا کنید.

            def generate_class(class_name, attributes):
 code = f"class {class_name}:\n"
 code += " def __init__(self, " + ", ".join(attributes) + "):\n"
 for attr in attributes:
 code += f" self.{attr} = {attr}\n"
 return code

class_code = generate_class("MyGeneratedClass", ["name", "age"])
print(class_code)
# Output:
# class MyGeneratedClass:
# def __init__(self, name, age):
# self.name = name
# self.age = age

exec(class_code)

obj = MyGeneratedClass("John", 30)
print(obj.name, obj.age) # Output: John 30

            

              
                Copy
              
            
          

استفاده از الگوها

یک رویکرد پیچیده تر استفاده از الگوها برای تولید کد است. کلاس string.Template در پایتون راهی ساده برای ایجاد الگوها ارائه می دهد.

            from string import Template

def generate_class_from_template(class_name, attributes):
 template = Template("""
class $class_name:
 def __init__(self, $attributes):
 $attribute_assignments
""")

 attribute_string = ", ".join(attributes)
 attribute_assignments = "\n".join([f" self.{attr} = {attr}" for attr in attributes])

 code = template.substitute(class_name=class_name, attributes=attribute_string, attribute_assignments=attribute_assignments)
 return code

class_code = generate_class_from_template("MyTemplatedClass", ["name", "age"])
print(class_code)
# Output:
# class MyTemplatedClass:
# def __init__(self, name, age):
# self.name = name
# self.age = age

exec(class_code)

obj = MyTemplatedClass("John", 30)
print(obj.name, obj.age)

            

              
                Copy
              
            
          

موارد استفاده برای تولید کد

• تولید ORM: تولید کلاس ها بر اساس طرحواره های پایگاه داده.
• تولید مشتری API: تولید کد مشتری بر اساس تعاریف API.
• تولید فایل پیکربندی: تولید فایل های پیکربندی بر اساس الگوها و ورودی کاربر.
• تولید کد صفحه بویلر: تولید کد تکراری برای پروژه ها یا ماژول های جدید.

وصله میمون: اصلاح کد در زمان اجرا

وصله میمون عمل اصلاح یا گسترش کد در زمان اجرا است. این می تواند برای رفع اشکالات، افزودن ویژگی های جدید یا انطباق کد با محیط های مختلف مفید باشد. با این حال، باید با احتیاط استفاده شود، زیرا می تواند درک و نگهداری کد را دشوارتر کند.

اصلاح کلاس های موجود

می توانید کلاس های موجود را با افزودن روش ها یا ویژگی های جدید یا با جایگزینی روش های موجود تغییر دهید.

            class MyClass:
 def my_method(self):
 print("Original method")

def new_method(self):
 print("Monkey-patched method")

MyClass.my_method = new_method

obj = MyClass()
obj.my_method()  # Output: Monkey-patched method

            

              
                Copy
              
            
          

اصلاح ماژول ها

همچنین می توانید ماژول ها را با جایگزینی توابع یا افزودن موارد جدید تغییر دهید.

            import math

def my_sqrt(x):
 return x / 2  # Incorrect implementation for demonstration purposes

math.sqrt = my_sqrt

print(math.sqrt(4))  # Output: 2.0

            

              
                Copy
              
            
          

هشدارها و بهترین شیوه ها

• به ندرت استفاده کنید: وصله میمون می تواند درک و نگهداری کد را دشوارتر کند. فقط در صورت لزوم از آن استفاده کنید.
• به وضوح مستند کنید: اگر از وصله میمون استفاده می کنید، آن را به وضوح مستند کنید تا دیگران بفهمند که چه کاری انجام داده اید و چرا.
• از وصله کتابخانه های اصلی خودداری کنید: وصله کتابخانه های اصلی می تواند عوارض جانبی غیرمنتظره ای داشته باشد و کد شما را کمتر قابل حمل کند.
• جایگزین ها را در نظر بگیرید: قبل از استفاده از وصله میمون، در نظر بگیرید که آیا راه های دیگری برای دستیابی به همان هدف وجود دارد، مانند زیر کلاس بندی یا ترکیب.

موارد استفاده برای وصله میمون

• رفع اشکالات: رفع اشکالات در کتابخانه های شخص ثالث بدون منتظر ماندن برای به روز رسانی رسمی.
• توسعه ویژگی: افزودن ویژگی های جدید به کد موجود بدون اصلاح کد منبع اصلی.
• تست: مسدود کردن اشیاء یا توابع در طول آزمایش.
• سازگاری: انطباق کد با محیط ها یا پلتفرم های مختلف.

مثال ها و کاربردهای دنیای واقعی

تکنیک های برنامه نویسی متا در بسیاری از کتابخانه ها و چارچوب های محبوب پایتون استفاده می شود. در اینجا چند نمونه آورده شده است:

• Django ORM: Django's ORM از فراداده ها برای نگاشت کلاس ها به جداول پایگاه داده و ویژگی ها به ستون ها استفاده می کند.
• Flask: Flask از دکوراتورها برای تعریف مسیرها و رسیدگی به درخواست ها استفاده می کند.
• SQLAlchemy: SQLAlchemy از فراداده ها و ویژگی های پویا برای ارائه یک لایه انتزاعی پایگاه داده انعطاف پذیر و قدرتمند استفاده می کند.
• attrs: کتابخانه `attrs` از دکوراتورها و فراداده ها برای ساده کردن فرآیند تعریف کلاس ها با ویژگی ها استفاده می کند.

مثال: تولید خودکار API با برنامه نویسی متا

سناریویی را تصور کنید که در آن شما نیاز به تولید یک مشتری API بر اساس یک فایل مشخصات (مثلاً OpenAPI/Swagger) دارید. برنامه نویسی متا به شما امکان می دهد این فرآیند را خودکار کنید.

            import json

def create_api_client(api_spec_path):
 with open(api_spec_path, 'r') as f:
 api_spec = json.load(f)

 class_name = api_spec['title'].replace(' ', '') + 'Client'

 class_attributes = {}
 for path, path_data in api_spec['paths'].items():
 for method, method_data in path_data.items():
 operation_id = method_data['operationId']

 def api_method(self, *args, **kwargs):
 # Placeholder for API call logic
 print(f"Calling {method.upper()} {path} with args: {args}, kwargs: {kwargs}")
 # Simulate API response
 return {"message": f"{operation_id} executed successfully"}

 api_method.__name__ = operation_id # Set dynamic method name
 class_attributes[operation_id] = api_method

 ApiClient = type(class_name, (object,), class_attributes) # Dynamically create the class
 return ApiClient

# Example API Specification (simplified)
api_spec_data = {
 "title": "My Awesome API",
 "paths": {
 "/users": {
 "get": {
 "operationId": "getUsers"
 },
 "post": {
 "operationId": "createUser"
 }
 },
 "/products": {
 "get": {
 "operationId": "getProducts"
 }
 }
 }
}

api_spec_path = "api_spec.json" # Create a dummy file for testing
with open(api_spec_path, 'w') as f:
 json.dump(api_spec_data, f)

ApiClient = create_api_client(api_spec_path)
client = ApiClient()
print(client.getUsers())
print(client.createUser(name="New User", email="new@example.com"))
print(client.getProducts())

            

              
                Copy
              
            
          

در این مثال، تابع create_api_client یک مشخصات API را می خواند، به طور پویا یک کلاس با روش هایی متناظر با نقاط پایانی API تولید می کند و کلاس ایجاد شده را برمی گرداند. این رویکرد به شما امکان می دهد به سرعت مشتریان API را بر اساس مشخصات مختلف بدون نوشتن کد تکراری ایجاد کنید.

مزایای برنامه نویسی متا

• افزایش انعطاف پذیری: برنامه نویسی متا به شما امکان می دهد کدی ایجاد کنید که می تواند با موقعیت ها یا محیط های مختلف سازگار شود.
• تولید کد: خودکارسازی تولید کد تکراری می تواند در زمان صرفه جویی کند و خطاها را کاهش دهد.
• سفارشی سازی: برنامه نویسی متا به شما امکان می دهد رفتار کلاس ها و توابع را به گونه ای سفارشی کنید که در غیر این صورت امکان پذیر نبود.
• توسعه چارچوب: برنامه نویسی متا برای ساخت چارچوب های انعطاف پذیر و قابل گسترش ضروری است.
• بهبود قابلیت نگهداری کد: در حالی که به ظاهر غیرمنطقی به نظر می رسد، هنگامی که از برنامه نویسی متا با تدبیر استفاده شود، می تواند منطق مشترک را متمرکز کند و منجر به کاهش تکرار کد و سهولت نگهداری شود.

چالش ها و ملاحظات

• پیچیدگی: برنامه نویسی متا می تواند پیچیده و دشوار برای درک باشد، به خصوص برای مبتدیان.
• اشکال زدایی: اشکال زدایی کد برنامه نویسی متا می تواند چالش برانگیز باشد، زیرا کدی که اجرا می شود ممکن است کدی نباشد که شما نوشته اید.
• قابلیت نگهداری: استفاده بیش از حد از برنامه نویسی متا می تواند درک و نگهداری کد را دشوارتر کند.
• عملکرد: برنامه نویسی متا گاهی اوقات می تواند تأثیر منفی بر عملکرد داشته باشد، زیرا شامل تولید و اصلاح کد در زمان اجرا می شود.
• خوانایی: اگر به دقت اجرا نشود، برنامه نویسی متا می تواند منجر به کدی شود که خواندن و درک آن دشوارتر است.

بهترین شیوه ها برای برنامه نویسی متا

• به ندرت استفاده کنید: فقط در صورت لزوم از برنامه نویسی متا استفاده کنید و از استفاده بیش از حد از آن خودداری کنید.
• به وضوح مستند کنید: کد برنامه نویسی متا خود را به وضوح مستند کنید تا دیگران بفهمند که چه کاری انجام داده اید و چرا.
• به طور کامل آزمایش کنید: کد برنامه نویسی متا خود را به طور کامل آزمایش کنید تا مطمئن شوید که مطابق انتظار کار می کند.
• جایگزین ها را در نظر بگیرید: قبل از استفاده از برنامه نویسی متا، در نظر بگیرید که آیا راه های دیگری برای دستیابی به همان هدف وجود دارد.
• ساده نگه دارید: تلاش کنید تا کد برنامه نویسی متا خود را تا حد امکان ساده و سرراست نگه دارید.
• اولویت بندی خوانایی: اطمینان حاصل کنید که ساختارهای برنامه نویسی متا شما تأثیر قابل توجهی بر خوانایی کد شما نمی گذارند.

نتیجه

برنامه نویسی متا پایتون ابزاری قدرتمند برای ایجاد کد انعطاف پذیر، قابل تنظیم و سازگار است. در حالی که می تواند پیچیده و چالش برانگیز باشد، طیف گسترده ای از امکانات را برای تکنیک های برنامه نویسی پیشرفته ارائه می دهد. با درک مفاهیم و تکنیک های کلیدی و با پیروی از بهترین شیوه ها، می توانید از برنامه نویسی متا برای ایجاد نرم افزارهای قدرتمندتر و قابل نگهداری تر استفاده کنید.

چه در حال ساخت چارچوب ها باشید، چه در حال تولید کد باشید یا در حال سفارشی سازی کتابخانه های موجود، برنامه نویسی متا می تواند به شما کمک کند مهارت های پایتون خود را به سطح بالاتری ببرید. به یاد داشته باشید که از آن با تدبیر استفاده کنید، آن را به خوبی مستند کنید و همیشه خوانایی و قابلیت نگهداری را در اولویت قرار دهید.