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

در ابتدای این مطلب از مجله فرادرس، با دستور Type در پایتون، آشنا می‌شویم. سپس دو نوع سینتکس مختلف را برای این دستور مرور کرده و دو کاربرد متفاوت تابع type() را با کمک مثال‌های مختلف کدنویسی شده بررسی می‌کنیم. بعد از آن هم روش تعریف کلاس با کمک این تابع را توضیح داده‌‌ایم. و در نهایت، انواع محدودیت‌های موجود در به‌کارگیری تابع type() را همراه با راه‌حل‌های ارائه شده توسط پایتون بررسی کردیم.

دستور Type در پایتون چیست؟

در پایتون، برای ذخیره عناصر داده‌ای در متغیرها نیازی به مشخص کردن نوع برای هر داده به صورت صریح وجود ندارد. یعنی خود پایتون به شکل خودکار نوع داده‌های ذخیره شده را تشخیص می‌دهد. بنابراین، اگر بخواهیم از نوع داده ذخیره شده در متغیرها باخبر شویم، باید از تابع «درونی» (Built-In)، type() در پایتون استفاده کنیم. دستور Type در پایتون، یکی از توابع درونی این زبان برنامه‌نویسی است. این دستور برای نشان دادن نوع داده ذخیره شده در پارامترهای تابع بر اساس آرگومان‌های ارسال شده به آن به کار می‌رود. دو شکل مختلف از تابع type() وجود دارد. به این معنا که می‌توانیم با دو روش مختلف به تابع type() آرگومان‌ ارسال کرده و دو نتیجه متفاوت نیز دریافت کنیم.

سینتکس تابع Type

بنابر مطلب گفته شده در بالا به دو صورت می‌توان سینتکس تابع type()را نمایش داد. در کادر زیر هر دو روش را کدنویسی کرده‌ایم.

1type(object)
2
3type(name, bases, dict)

پارامترهای مورد استفاده در سینتکس‌های بالا را در فهرست زیر توضیح داده‌ایم.

• object : هر مقدار داد‌ه، متغیر یا شیء که در این‌جا به تابع type()ارسال شود، توسط تابع بررسی شده و نوع آن برگشت داده می‌شود.
• name : این پارامتر نام کلاس را نشان می‌دهد. به صورت ویژگی ___name___  در کلاس تعریف می‌شود. درباره این پارامتر در بخش‌های بعدی بیشتر توضیح داده‌ایم.
• bases : از نوع داده تاپل در پایتون است. کلاس فعلی از این تابع مشتق شده است. به صورت ویژگی ــbases ــ  تعریف می‌شود.
• dict : دیکشنری که فضای نام مورد استفاده برای کلاس را مشخص می‌کند. بعدا به ویژگی ــdictــ  در کلاس، تبدیل می‌شود.

در کادر بالا سینتکس مربوط به هر دو روش را نمایش داده‌ایم. در روش اول، تابع type() فقط یک پارامتر به صورت مجزا دریافت می‌کند، اما در روش دوم، سه پارامتر برای استفاده می‌پذیرد.

اگر به تابع type(object)  آرگومانی را به صورت تنها ارسال کنیم، دستور Type فقط نوع شیء داده شده object را به بیرون برمی‌گرداند. اما هنگامی که سه آرگومان به تابع type(name, bases, dict) ارسال کنیم، به صورت خودکار کلاسی را ایجاد می‌کند و شیئی را با نوع جدید به بیرون برمی‌گرداند.

در بخش بعدی به صورت مفصل‌تری به مبحث کاربرد دوگانه تابع type() می‌پردازیم.

روش استفاده از تابع Type

می‌توان گفت که در واقع این تابع به منظور استفاده در دو نوع سناریو جداگانه به‌کار برده می‌شود.

1. برای بدست آوردن نوع  هر داده در پایتون ارسال شده به تابع
2. برای ساخت نوع داده جدید به صورت خودکار

در ابتدا استفاده از این تابع را به روش اول، بررسی می‌کنیم. روش اول تقریبا به صورت روزانه توسط برنامه نویسان پایتون استفاده می‌شود.

پیدا کردن نوع داده اشیا با کمک تابع Type

پایتون از نوع زبان‌های برنامه نویسی خودکار است. به این معنا که نوع هر داده‌ فقط در زمان اجرا مشخص می‌شود و ارتباط مستقیم با مقدار ذخیره شده در متغیرها دارد. با این شرایط تعیین نوع اشیاء در زمان اجرا اجباری می‌شود.

برای مثال، می‌خواهیم که دستور Type در پایتون را فراخوانی کرده و شیئی را به عنوان تنها پارامتر آن به تابع ارسال کنیم. در خروجی تابع، نوع شیء ارسال شده را بدست خواهیم آورد. به عنوان مثال در خروجی، مقادیر int یا str نمایش داده خواهند شد.

1assert type(42) == int
2# Type of `str(42)` is `str`
3assert type(str(42)) == str

اگر تابع type()را در «دستورات اساسی پایتون برای خواندن، ارزیابی و چاپ داده‌ها یا حلقه‌های پایتون» (REPL) فراخوانی کنیم، نمایش متنی شی‌ء برگشت داده شده به‌جای کلمه ‘type’ از کلمه ‘class’ استفاده خواهد کرد.

توجه کنید: «دستورات اساسی پایتون» (The Python Standard Shell) برای خواندن، ارزیابی و چاپ داده‌ها یا حلقه‌های پایتون که معادل با «Read-Eval-Print Loop» هستند، به صورت اختصاصی REPL نامیده می‌شوند. در واقع کلمه REPL سرنامی از نام‌های این عملیات است.

1# Returns "<class 'int'>" inside REPL
2type(42)

چیزی که اینجا در ابتدا گیج کننده به نظر می‌رسد، درواقع بسیار هم منطقی است. زیرا در پایتون همه‌چیز شیء هستند. در زبان برنامه نویسی پایتون، نوع هر شیء مطابق با کلاس آن تعیین می‌شود. بنابراین، فراخوانی تابع type() در پایتون به طور کلی برابر با خواندن ویژگی __class__  از هر کلاس است.

1# Should hold in most cases
2assert type(obj) is obj.__class__

ساخت نوع داده جدید با کمک دستور Type در پایتون

در این بخش به بررسی دومین روش استفاده از تابع Type می‌پردازیم. این تابع در زمان فراخوانده شدن با سه آرگومان می‌تواند به صورت خودکار نوع داده جدیدی را ایجاد کند.

1type(name, bases, dict, **kwds)

در این شکل استفاده از تابع، دستور Type در پایتون شبیه به کلمه کلیدی class رفتار می‌کند. در واقع می‌توانیم کد type = type(“Type”, bases, dict) را برابر با تعریف کلاس در پایتون در نظر بگیریم.

1class <Type>(<bases>):
2    <dict>

در جدول زیر مثالی از شبیه‌سازی رفتار تابع Type را برای تعریف کردن نوع داده‌های جدید نمایش داده‌ایم. تابع Type نوع جدید را از طریق تعریف کلاس جدید ایجاد می‌کند. در جدول زیر، آرگومان‌های مورد استفاده در تابع type(name, bases, dict, **kwds)  را توضیح داده‌ایم.

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

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

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

یکی دیگر از گزینه‌های بسیار خوب برای شروع یادگیری زبان برنامه‌نویسی پایتون، مشاهده فیلم رایگان آموزش برنامه نویسی سریع و آسان پایتون در ۱۴۰ دقیقه از فرادرس است. مواردی که در ادامه معرفی کرده‌ایم مربوط به کسانی است که دوره آموزش اولیه پایتون را گذرانده و در پی ارتقای سطح مهارت‌های خود هستند.

تابع Type چگونه کار می‌کند؟

طبق مطالبی که گفته شد، تابع Type دو کار بسیار مهم در پایتون انجام می‌دهد. اولین کار تشخیص نوع داد‌ه‌ها، مقادیر درون متغیرها یا اشیا است و وظیفه دوم این تابع نیز تعریف کلاس‌ در زمان اجرای برنامه است. اما برای استفاده‌ بهتر از امکانات این تابع لازم است که انواع تکنیک‌های کدنویسی پیشرفته پایتون را بلد باشیم. به همین منظور، تماشای فیلم آموزش برنامه نویسی پایتون پیشرفته همراه با ترفندهای Python از فرادرس را به شما پیشنهاد می‌دهیم. برای راحتی بیشتر، لینک مربوط به این فیلم آموزشی را در ادامه قرار داده‌ایم.

وقتی که از تابع Type برای مشخص کردن نوع داده شیئی استفاده می‌کنیم، مقدار برگشت داده شده از نوع استرینگ در برنامه نویسی نیست، بلکه شیئی با نوع مستقل است.

1# Value returned by `type(42)` is not a string
2assert type(42) != 'int'
3# We get back an object named `int`
4assert type(42) == int

در ادامه به چند مثال گوناگون از مقادیر بازگشتی تابع type() نگاه می‌کنیم. هر کدام از مثال‌ها را با ارسال اشیائی با نوع داده مختلف اجرا کرده‌ایم.

1# Python objects of different types
2different_objs = None, True, 42, 'John', ('Walter', 'White'), ...
3# Print out the type of each object
4for obj in different_objs:
5    print(f"{obj}: {type(obj)}")

خروجی مربوط به کدهای بالا را در جدول زیر نمایش داده‌ایم.

سوالی که با توجه به جدول بالا ایجاد می‌شود این است که نوع داده شیئی که توسط تابع type() برگردانده می‌شود، چیست؟

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

1# Returns: "<class 'type'>"
2type(type(42))

کد بالا نشان می‌دهد که علاوه بر تابع درونی type() در پایتون، نوع داده‌‌ای هم با نام یکسان «type» وجود دارد. این «type» همه نوع داده‌های دیگر پایتون را نمایش می‌دهد. در کد زیر همراه با مثال ساده‌ای این مسئله را نمایش داده‌ایم.

1# DifferentPython objects
2different_objs = None, True, 42, 'John', ('Walter', 'White'), ...
3# Check the type of each object's type
4for obj in different_objs:
5    # Show that the type’s type is always `type`
6    assert type(type(obj)) is type

بنابراین نوع اصلی هر نوعی در پایتون از نوع «type» است. اگر این مطلب در نگاه اول، گمراه کننده باشد می‌توان به صورت بهتری هم بیان کرد که شیء «type» در پایتون، برای خود یک نوع به حساب می‌آید. این تعاریف را می‌توان برای همیشه ارائه داد. تقریبا مانند ماری است که دم خود را می‌خورد.

1# It's `type` all the way down
2assert type(type(type(type))) is type

برای برطرف کردن همه ابهام‌ها ضروری است که به صورت عمیق‌تری به مبحث «برنامه نویسی شی گرایی» (Object-Oriented Programming | OOP) در پایتون بپردازیم. شیء type ساخته شده در پایتون نمایش‌دهنده ویژگی به‌ نام «metaclass» است. رفتار «metaclass» در مقابل کلاس‌های پایتون مانند رفتار کلاس‌ها در مقابل اشیا است. به عبارت دیگر، «metaclass» در واقع قالبی برای کلاس‌ است، همان‌طور که کلاس قالبی برای شیء به حساب می‌آید.

در جدول زیر سعی کردیم که این مطلب را به صورت بسیار شفاف‌تر و ساده‌تری بیان کنیم.

زمان استفاده از دستور Type در پایتون

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

1// Declare variable as `boolean`
2boolean answer;
3// Attempting to assign `int` value
4// Throws type error
5answer = 42;

به بیان دیگر، متغیرها در پایتون، نام‌های ساده‌ای هستند که فقط به مقادیر دورنشان اشاره می‌کنند. نوع این مقادیر از پیش مشخص شده است. در هر لحظه از زمان اجرای کد، این نام می‌تواند به مقداری با نوع داده متفاوت اشاره کند. بنابراین برای مشخص کردن نوع مقادیر درون متغیرهای پایتون در زمان اجرا، نیاز به تابعtype() داریم.

1# Assign Boolean value
2answer = True
3# Show that type is `bool`
4assert type(answer) is bool
5# Reassign integer value
6answer = 42
7# Show that type is now `int`
8assert type(answer) is int

بررسی نوع آرگومان های تابع در پایتون

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

در این بخش از مطلب می‌خواهیم استفاده از تابع type() را با کمک مثالی نمایش دهیم. تابعی تعریف می‌کنیم که باید لیستی از اعداد را با یکدیگر جمع بزند. برای این کار نیاز داریم، مطمئن شویم که تمام عنصرهای درون لیست از جنس عدد هستند. در نوشتن کدهای برنامه گفته شده، از تابع type() درون عبارت assert استفاده خواهیم کرد.

1# Function to add up numeric arguments
2def add_numbers(*args):
3    result = 0
4    # Check each argument
5    for arg in args:
6        # Abort with error message if argument is not an `int` or `float`
7        assert type(arg) in (int, float), f"Argument `{arg}` is not a number"
8        # Add argument's value to total
9        result += arg
10    return result
11# Show that it works for numbers
12assert add_numbers(35, 7) == 42
13# The following will fail
14add_numbers(29, 'thirteen')

خطایابی در Python REPL با استفاده از تابع Type

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

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

برای کمک به درک بهتر مطلب گفته شده در ابتدای این بخش، سناریو خاصی را تصور می‌کنیم. فرض کنیم که کد نوشته شده شامل متغیری به نام answer است. این متغیر قرار است که حاوی مقداری از نوع Boolean باشد. متوجه شده‌ایم که نوع داده موجود در این متغیر با انتظارات برنامه‌نویس همخوانی ندارد. بنابراین، از تابع type() پایتون برای فهمیدن نوع داده موجود در متغیر استفاده می‌کنیم. همین‌طور که معلوم است‌، به صورت تصادفی مقدار بولین را در کوتیشن‌ نوشته‌ایم. می‌دانیم که کوتیشن برای مشخص کردن رشته به‌کار برده می‌شود. این اشتباه مخصوصا در بین تازه‌کارها بسیار رایج است.

1# Accidentally set to string
2answer = 'False'
3# Assertion will fail
4assert type(answer) is bool
5# Correct to Boolean value
6answer = False
7# Now assertion holds
8assert type(answer) is bool

تولید کلاس های پایتون به صورت خودکار با استفاده از تابع Type

همین‌طور که در بخش‌های بالاتر دیدیم، با کمک تابع type() می‌توان به صورت خودکار کلاس ایجاد کرد. این کار را در پایتون می‌توان به صورت همزمان با اجرای برنامه نیز انجام داد. چنین قابلیتی برای خانواده کلاس‌ها در میان سایر امکانات پایتون امتیاز بزرگی است. شیء‌گرایی یکی از امتیازات و نقاط قوت پایتون است. البته داشتن این مزیت مستلزم توانایی استفاده از آن هم هست. در صورتی که به کسب دانش و تجربه بیشتری نیاز دارید، پیشنهاد می‌کنیم که فیلم آموزش برنامه نویسی شی گرا در پایتون از فرادرس را مشاهده کنید. برای راحتی کار مخاطبان عزیز، لینک مربوط به این فیلم را در ادامه قرار داده‌ایم.

در مثال بعدی می‌خواهیم مفهوم خانواده‌های کلاس‌ها را با استفاده از تگ‌های HTML نمایش دهیم. در ابتدای کار کلاس پایه‌ای به نام tag ایجاد می‌کنیم. اشیا این کلاس می‌توانند خود را به عنوان کدهای HTML نمایش دهند.

1# Class representing HTML tag
2class Tag:
3    # Initialize HTML tag with contents
4    def __init__(self, *args):
5        # Join contents of tag
6        self.content = "".join([arg.__str__() for arg in args])
7    # String representation returns HTML
8    def __str__(self):
9        return f"<{self.name}>{self.content}</{self.name}>"

از طریق وراثت در پایتون، می‌خواهیم که کلاس پایه را به تگ‌های مخصوص HTML مانند <p> یا <h1>، اختصاص دهیم. به منظور انجام این‌کار دوباره از تابع type() استفاده خواهیم کرد. در کادر زیر مطلب گفته شده را با استفاده از مثال کوچکی نمایش می‌دهیم.

1# Create `P` class
2P = type('P', (Tag,), {"name": 'p'})

کل اتفاقی که در کد بالا روی داده را به صورت فهرستی در پایین توضیح داده‌ایم.

1. ‘P’ : کلاس جدید را با نوع رشته نام گذاری می‌کنیم.
2. (Tag,) : تاپلی را با کلاس‌های پایه قرار داده‌ایم. پایتون اجازه وراثت چندگانه را می‌دهد، اما باید به صورت (ClassName,) از تاپل استفاده کنیم تا بتوانیم کلاس جدید را فقط از روی یک کلاس به صورت مجزا مشتق کنیم.
3. {“name”: ‘p’} : دیکشنری شامل نام کلاس است. در صورت لزوم می‌توان موارد ورودی بیشتری اضافه کرد. موارد ورودی اضافه می‌توانند از هر نوع، حتی تابع باشند.

پس از آن، نمونه‌ای از تگ <p> را ایجاد می‌کنیم و بررسی می‌کنیم که نمایش به درستی کار ‌کند.

1# Instantiate `p` tag
2greeting = P("Hello world")
3assert str(greeting) == '<p>Hello world</p>'

همچون تاثیر یکسانی را می‌توان به وسیله تعریف کلاس مشابه نیز بدست آورد.

1# Create `P` class
2class P(Tag):
3    name = 'p'

به عنوان مثال بعدی، کلاس‌هایی را هم برای Heading-ها headings به وسیله تابع type()در پایتون ایجاد می‌کنیم.

برای انجام این کار دو ابزار قدرتمند در دست داریم.

1. با به‌کار بردن تابع Type میتوانیم کلاس‌های مورد نظر خود را به صورت پویا ایجاد کنیم.
2. تکنیک تعریف لیست به نام List Comprehension، مانند حلقه‌ای می‌تواند چندین عملیات مشابه هم را پشت سر هم اجرا کند.

با کمک این دو ابزار می‌توانیم برای همه شش سطح Heading به طور همزمان کلاس‌های مربوط به آن‌ها را ایجاد کنیم.

1h_1_to_6 = ( f"h{n}" for n in range(1, 7) )
2headings = [type(heading, (Tag,), {"name": heading}) for heading in h_1_to_6]

همین‌طور که نشان داده شد، تابع type() برای ساخت چندین زیرکلاس مرتبط به صورت یکجا ارزش استفاده را دارد. در مثال بعدی این رویکرد کدنویسی را با کمک مسئله پیچیده‌تری درباره تعریف کلاس‌ها برای مدل‌سازی بازی کارت نشان می‌دهیم. در ابتدا با استفاده از کلمه کلیدی class ، اَبَرکلاسی به نام Card ایجاد می‌کنیم.

1# Class representing abstract playing card
2class Card:
3    def __init__(self, number):
4        self.number = number
5    # String representation
6    def __str__(self):
7        return f"{self.number} of {self.suite}"

در مرحله بعد با استفاده از تابع type()، زیر کلاس‌هایی را برای چهار رنگ مختلف کارت‌های بازی می‌سازیم.

1# Create concrete types for each suite
2Clubs = type('Clubs', (Card,), {'suite': 'Clubs'})
3Diamonds = type('Diamonds', (Card,), {'suite': 'Diamonds'})
4Hearts = type('Hearts', (Card,), {'suite': 'Hearts'})
5Spades = type('Spades', (Card,), {'suite': 'Spades'})

الان به‌سادگی می‌توانیم کارت‌های مجزا را نمونه‌سازی کنیم.

1# Instantiate a 7 of Spades
2card = Spades(7)
3# Show that it worked
4assert str(card) == '7 of Spades'

دستور Type در پایتون چه محدودیت هایی دارد؟

دستور Type در پایتون بسیار مفید است. اما هنوز هم بعضی موارد هستند که استفاده از این تابع در آن‌ها با محدودیت و مشکل مواجه می‌شود. خوشبختانه پایتون راه‌حل‌هایی را برای هر مشکل ارائه داده است.

در این بخش از مطلب به چند مورد از راه‌حل‌های ارائه شده نگاه می‌کنیم.

کشف سلسله مراتب وراثتی با استفاده از تابع isinstance

تابع type() فقط نوع واقعی اشیاء پایتون را مشخص می‌کند، اما سلسله مراتب وراثتی را نادیده می‌گیرد. به منظور روشن‌تر شدن مطلب، از مثال کارت‌های بازی زده شده در بخش قبل برای نشان دادن این معضل استفاده می‌کنیم. یعنی نوع داده عدد «۷ پیک» باید از هر دو نوع «کارتِ بازی» و «پیک» در کنار هم باشد. اما با استفاده از تابع type() نمی‌توان دو نوع مختلف را مشخص کرد.

1# Create a Seven of Spades
2card = Spades(7)
3# Our card is a Spade alright
4assert type(card) is Spades
5# But not a card??
6assert type(card) is not Card

برای این بتوانیم به صورت صحیح نوع شیء خاصی را مشخص و مسئله چند ریختی را مدیریت کنیم، باید از تابع isinstance()  استفاده کنیم.

1# Seven of Spades is a `Spade`
2assert isinstance(card, Spades)
3# And is also a `Card`
4assert isinstance(card, Card)

ساده سازی تشخیص نوع در پایتون با استفاده از match-case

همان‌طور که در بخش‌های بالایی مطلب گفته شد، از تابع type() در پایتون اغلب برای مشخص کردن نوع اشیا در زمان اجرا استفاده می‌شود. برای تشخیص چندین نوع متفاوت از یکدیگر برای هر داده، در صورت نیاز باید ساختار if-elif-else را به‌کار بگیریم.

1# Determine type of object
2if type(obj) is int:
3    print("Int")
4elif type(obj) is float:
5    print("Float")
6elif type(obj) is ...:
7    print("...")
8else:
9    print("Something else")

پایتون عبارت match-case را در نسخه ۳٫۱۰ معرفی کرد. این عبارت برای تشخیص نوع اشیا بدون نیاز به استفاده از تابع type() به‌کار برده می‌شود.

در بلوک case ، می‌توان از توابع سازنده‌ای مانند int(obj) یا str(obj) برای تطبیق دادن بلوک با شیء استفاده کرد، اما به شرطی که شی‌ء از نوع مرتبط با مورد مشخص شده در caseباشد. در کادر پایین می‌توان دید که توابع سازنده در مقابل caseتعریف شده‌اند.

1# Example object
2obj = 42
3# Determine object type
4match obj:
5    case int(obj):
6        print(f"{obj} is `int`")
7    case float(obj):
8        print(f"{obj} is `float`")
9    case _:
10        print(f"{obj} is something else")

یادگیری حرفه‌ای پایتون با فرادرس

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

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

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

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

جمع بندی

یادگیری استفاده از دستور Type در پایتون، برای بررسی نوع اشیا به صورت موثر و خطایابی در کدهای برنامه، بسیار ضروری است. این ابزار قدرتمند به شناسایی نوع داده‌ در متغیرها، تضمین اجرای روان و منظم و کارآمدی برنامه کمک می‌کند. تسلط به کار با تابع type() به برنامه‌نویسان برای نوشتن برنامه‌های مستحکم و اسکریپت‌های پایتون بدون خطا کمک می‌کند. دستور Type در پایتون، علاوه بر کمک به شناخت نوع مقادیر ذخیره شده در متغیرها کاربرد اساسی دیگری هم دارد. این کاربرد بسیار جالب ساختن زیرکلاس‌ها با توجه به مشخصات تعیین شده در زمان اجرای برنامه است.

در این مطلب از مجله فرادرس، با دستور type() آشنا شدیم و فهمیدیم که دو کاربرد مجزا از هم و بسیار مفید دارد. سینتکس مربوط به هردو کاربرد را با کمک مثال‌هایی برای درک بهتر و آموزش بیشتر نمایش دادیم. انواع استفاده‌های ممکن از تابع type() را نمایش داده و برای هر کدام مثال مربوط به آن را نیز ارائه و توضیح دادیم. در نهایت هم محدودیت‌های موجود بر سر استفاده از تابع type() را بیان کرده و راه حل برطرف کردن آن‌ها نیز بررسی کردیم.