ویژگی های پنهان پایتون

معرفی

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

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

بررسی ویژگی های پنهان پایتون

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

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

_ (Underscore) در پایتون

یکی از جواهرات پنهان پایتون زیرخط (_). این یک کاراکتر همه کاره است که می تواند به روش های مختلف در کد پایتون استفاده شود.

ابتدا می توان از آن به عنوان یک متغیر در پایتون استفاده کرد. اغلب به عنوان یک متغیر دور ریختنی استفاده می شود، به عنوان مثال، متغیری که اعلام می شود اما مقدار آن در واقع استفاده نمی شود.

for _ in range(5):
    print("Hello, World!")

در کد بالا، ما از متغیر استفاده نمی کنیم _ در هر جایی، فقط آنجاست، زیرا یک متغیر توسط نحو مورد نیاز است for حلقه

دومین، _ برای نادیده گرفتن مقادیر خاص استفاده می شود. اگر به مقادیر خاصی نیاز ندارید یا از مقادیر استفاده نمی شود، فقط مقادیر را به خط زیر اختصاص دهید.

x, _, y = (1, 2, 3) 

در اینجا ما به هر دو مورد نیاز داریم x و y متغیرها، اما سینتکس پایتون به ما اجازه نمی دهد آنها را بدون چیزی در بین اعلام کنیم، بنابراین از خط زیر استفاده می کنیم.

آخر، در پایتون console، _ آخرین مقدار عبارت اجرا شده را نشان می دهد.

>>> 10 + 20
30
>>> _
30

اشکال زدایی Regex از طریق Parse Tree

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

کد زیر را در نظر بگیرید:

import re

re.compile("(\d+)\.(\d+)", re.DEBUG)

این خروجی خواهد داشت:

SUBPATTERN 1 0 0
  MAX_REPEAT 1 MAXREPEAT
    IN
      CATEGORY CATEGORY_DIGIT
LITERAL 46
SUBPATTERN 2 0 0
  MAX_REPEAT 1 MAXREPEAT
    IN
      CATEGORY CATEGORY_DIGIT

 0. INFO 4 0b0 3 MAXREPEAT (to 5)
 5: MARK 0
 7. REPEAT_ONE 9 1 MAXREPEAT (to 17)
11.   IN 4 (to 16)
13.     CATEGORY UNI_DIGIT
15.     FAILURE
16:   SUCCESS
17: MARK 1
19. LITERAL 0x2e ('.')
21. MARK 2
23. REPEAT_ONE 9 1 MAXREPEAT (to 33)
27.   IN 4 (to 32)
29.     CATEGORY UNI_DIGIT
31.     FAILURE
32:   SUCCESS
33: MARK 3
35. SUCCESS
re.compile('(\\d+)\\.(\\d+)', re.DEBUG)

این درخت تجزیه عبارت منظم است. نشان می دهد که عبارت منظم دارای دو الگوی فرعی است ((\d+) و (\d+)، با یک نقطه از هم جدا شده است (.).

این می تواند در هنگام اشکال زدایی عبارات منظم پیچیده بسیار مفید باشد. این یک نمایش واضح و بصری از بیان منظم شما به شما می دهد و دقیقاً نشان می دهد که هر قسمت از عبارت چه کاری انجام می دهد.

بیضی

بیضی پایتون یک ویژگی منحصر به فرد است که معمولاً در سایر زبان های برنامه نویسی دیده نمی شود. این با سه نقطه متوالی (…) نشان داده می شود و در واقع یک ثابت داخلی در پایتون است. ممکن است از خود بپرسید، این احتمالاً برای چه چیزی می تواند استفاده شود؟ بیایید برخی از کاربردهای آن را بررسی کنیم.

بیضی پایتون را می توان به عنوان یک مکان نگهدار برای کد استفاده کرد. این می تواند زمانی بسیار مفید باشد که ساختار برنامه را ترسیم می کنید اما هنوز همه قسمت ها را پیاده سازی نکرده اید. برای مثال:

def my_func():
    ...
    

در اینجا، بیضی نشان می دهد که my_func ناقص است و نیاز به اجرا دارد.

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

import numpy as np


arr = np.array((((1, 2, 3), (4, 5, 6)), ((7, 8, 9), (10, 11, 12))))


print(arr(..., 2))

این خروجی خواهد داشت:

(( 3  6)
 ( 9 12))

در این مورد، بیضی برای دسترسی به عنصر سوم هر زیر آرایه در آرایه سه بعدی ما استفاده می شود.

این dir() تابع

این dir() تابع یکی دیگر از جواهرات پنهان پایتون است. این یک تابع داخلی قدرتمند است که لیستی از نام ها را در محدوده محلی فعلی یا لیستی از ویژگی های یک شی را برمی گرداند.

وقتی بدون استدلال استفاده می شود، dir() لیستی از نام ها را در محدوده محلی فعلی برمی گرداند. در اینجا یک مثال است:

x = 1
y = 2

print(dir())

این چیزی شبیه به:

('__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'x', 'y')

اینجا، x و y متغیرهایی هستند که ما تعریف کردیم و بقیه نام‌های داخلی در پایتون هستند.

وقتی با یک شی به عنوان آرگومان استفاده می شود، dir() لیستی از ویژگی های شی را برمی گرداند. به عنوان مثال، اگر از آن با یک شی رشته استفاده کنیم:

print(dir('Hello, rasanegar!'))

این خروجی خواهد داشت:

('__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill')

اینها همه روش هایی هستند که می توانید با یک شی رشته استفاده کنید. dir() زمانی که می خواهید اشیاء پایتون را کاوش کنید و قابلیت های آنها را درک کنید، یک تابع مفید است.

توابع لامبدا

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

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

multiply = lambda x, y: x * y
print(multiply(5, 4))

خروجی:

20

در مثال بالا، یک تابع لامبدا ایجاد کرده ایم که دو عدد را با هم ضرب می کند. سپس تابع با اعداد 5 و 4 را فراخوانی می کنیم و 20 را برمی گرداند.

عملگرهای مقایسه زنجیره ای

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

به عنوان مثال، فرض کنید می خواهید بررسی کنید که آیا یک عدد بین 1 و 10 است یا خیر. به جای نوشتن دو مقایسه جداگانه و ترکیب آنها با یک عدد and اپراتور، می توانید این کار را انجام دهید:

x = 5
print(1 < x < 10)

خروجی:

True

در این مثال، 1 < x < 10 برابر است با 1 < x and x < 10. پایتون هم مقایسه ها را بررسی می کند و هم برمی گرداند True اگر هر دو درست باشد، درست مثل اینکه از آن استفاده کرده اید and اپراتور.

این zip() تابع

پایتون zip() عملکرد یک جواهر پنهان است که توجهی که شایسته آن است را به خود جلب نمی کند. این تابع که از نسخه 1.5 بخشی از پایتون بوده است، می‌تواند کد شما را پاک‌تر و کارآمدتر کند و به شما امکان می‌دهد چندین دنباله را به صورت موازی تکرار کنید.

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

names = ("Alice", "Bob", "Charlie")
ages = (25, 30, 35)

for name, age in zip(names, ages):
    print(f"{name} is {age} years old.")

و خروجی:

Alice is 25 years old.
Bob is 30 years old.
Charlie is 35 years old.

دکوراتورها

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

بیایید به یک مثال نگاه کنیم. فرض کنید تابعی دارید که عملیاتی را انجام می دهد، اما می خواهید با شروع و پایان عملیات وارد شوید. شما می توانید دستورات ورود به سیستم را مستقیماً به تابع اضافه کنید، اما کد شما را به هم می ریزد. درعوض، می‌توانید یک دکوراتور برای مدیریت ورود به سیستم ایجاد کنید:

def log_decorator(func):
    def wrapper():
        print("Starting operation...")
        func()
        print("Operation finished.")
    return wrapper

@log_decorator
def perform_operation():
    print("Performing operation...")

perform_operation()

وقتی این کد را اجرا می کنید، خروجی زیر را خواهید دید:

Starting operation...
Performing operation...
Operation finished.

این @log_decorator خط یک دکوراتور است. به پایتون می گوید تابع را پاس کند perform_operation() به log_decorator() تابع. این log_decorator() سپس تابع را می پیچد perform_operation() عملکرد با کد اضافی برای ثبت شروع و پایان عملیات.

مدیران زمینه و بیانیه “با”.

در پایتون، مدیران زمینه یک گوهر پنهان هستند که می توانند در مدیریت منابع بسیار مفید باشند. آنها به شما این امکان را می دهند که منابع را دقیقاً در زمانی که می خواهید اختصاص دهید و آزاد کنید. پرکاربردترین نمونه از مدیران زمینه است with بیانیه.

بیایید به یک مثال نگاه کنیم:

with open('hello.txt', 'w') as f:
    f.write('Hello, World!')

در این مثال، with دستور برای باز کردن یک فایل و اختصاص آن به متغیر استفاده می شود f. فایل برای مدت زمان باز نگه داشته می شود with مسدود می شود و به طور خودکار در پایان بسته می شود، حتی اگر استثناهایی در بلوک رخ دهد. این تضمین می کند که پاکسازی برای ما انجام می شود.

ژنراتورها و بیانیه بازده

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

این yield از دستور برای تعریف یک ژنراتور استفاده می شود که جایگزین آن می شود return یک تابع برای ارائه یک نتیجه برای تماس گیرنده خود بدون از بین بردن متغیرهای محلی.

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

def even_numbers(n):
    for i in range(n):
        if i % 2 == 0:
            yield i

for number in even_numbers(10):
    print(number)

خروجی:

0
2
4
6
8

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

این ویژگی‌های پنهان پایتون، مدیران زمینه و تولیدکنندگان، می‌توانند کد شما را کارآمدتر و خواناتر کنند. آنها ارزش درک و استفاده در کدنویسی روزمره پایتون را دارند.

متاکلاس ها

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

برای تعریف متاکلاس، ما معمولاً از داخلی ارث می بریم type کلاس بیایید به یک مثال ساده نگاهی بیندازیم:

class Meta(type):
    def __new__(cls, name, bases, attrs):
        print(f"Creating a new class named: {name}")
        return super().__new__(cls, name, bases, attrs)

class MyClass(metaclass=Meta):
    pass

با اجرای این کد، خروجی زیر را خواهید دید:

$ python3 metaclass_example.py
Creating a new class named: MyClass

در مثال بالا، Meta متاکلاس ما است که از آن به ارث می رسد type. آن را نادیده می گیرد __new__ متد که وظیفه ایجاد و برگرداندن یک شی جدید را بر عهده دارد. وقتی تعریف می کنیم MyClass با Meta به عنوان متاکلاس آن، __new__ روش از Meta فراخوانی می شود و پیام سفارشی خود را چاپ شده می بینیم.

نتیجه

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