دستور زبان رایج پایتون در علم داده (مقدماتی)

این روزها مشغول مطالعه کتاب Data Science from Scratch (لینک PDF) هستم که یک کتاب مقدماتی عالی و قابل فهم در حوزه علم داده است. یکی از فصل‌های آن به معرفی دستور زبان پایه پایتون و دستورات پیشرفته‌تر که در علم داده کاربرد فراوان دارند، پرداخته است. به نظرم توضیحاتش بسیار خوب، مختصر و واضح بود، به همین دلیل آن را برای یادآوری و استفاده خودم در اینجا ترجمه می‌کنم. دستور زبان رایج پایتون در علم داده (مقدماتی) دستور زبان رایج پایتون در علم داده (پیشرفته)

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

قالب‌بندی با فاصله (Indentation)

بسیاری از زبان‌های برنامه‌نویسی برای کنترل بلوک‌های کد از پرانتز یا کروشه استفاده می‌کنند، اما پایتون از تورفتگی (indentation) بهره می‌برد:

for i in [1, 2, 3, 4, 5]:
    print i          # اولین خط حلقه "for i"
    for j in [1, 2, 3, 4, 5]:
        print j      # اولین خط حلقه "for j"
        print i + j  # آخرین خط حلقه "for j"
    print i          # آخرین خط حلقه "for i"
print "done looping"

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

long_winded_computation = (1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20)

و همچنین کد را خواناتر می‌کند:

list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
easier_to_read_list_of_lists = [ [1, 2, 3],
                                 [4 ,5 ,6 ],
                                 [7 ,8 ,9 ] ]

دستورات چند خطی

می‌توانید برای اتصال دو خط کد که از هم جدا شده‌اند، از بک‌اسلش (\) استفاده کنید (این روش کمتر رایج است):

two_plus_three = 2 + \
                 3

ماژول‌ها (Modules)

چه ماژول‌های داخلی پایتون باشند و چه ماژول‌های شخص ثالثی که خودتان دانلود کرده‌اید، برای استفاده از آن‌ها باید به صورت دستی آن‌ها را وارد (import) کنید.

۱. وارد کردن مستقیم کل ماژول به صورت ساده:

import re
my_regex = re.compile("[0-9]+", re.I)

ماژول re که در اینجا وارد شده، برای کار با عبارات منظم (regular expressions) استفاده می‌شود. پس از وارد کردن ماژول، می‌توانید با استفاده از نام ماژول به عنوان پیشوند (re.)، توابع و قابلیت‌های آن را فراخوانی کنید.

۲. اگر نام ماژولی که قصد وارد کردن آن را دارید، قبلاً در کد شما استفاده شده است، می‌توانید در زمان وارد کردن، آن را به نام دیگری نگاشت (map) کنید:

import re as regex
my_regex = regex.compile("[0-9]+", regex.I)

۳. اگر اهل ریسک هستید، می‌توانید کل ماژول را به فضای نام (namespace) فعلی وارد کنید. این کار ممکن است به صورت ناخواسته متغیرهایی را که قبلاً تعریف کرده‌اید، بازنویسی کند:

match = 10
from re import *  # ماژول re تابعی به نام match دارد
print match       # تابع match را چاپ می‌کند

اما از آنجایی که شما آدم خوبی هستید، مطمئنم که هرگز چنین کاری نخواهید کرد.

عملیات ریاضی (Arithmetic)

پایتون 2.7 به صورت پیش‌فرض از تقسیم صحیح (integer division) استفاده می‌کند، بنابراین $ 5 / 2 = 2 $. اما در بسیاری از مواقع، ما به تقسیم صحیح نیاز نداریم، بنابراین می‌توانیم این ماژول را وارد کنیم:

from __future__ import division

پس از وارد کردن آن، $5 / 2 = 2.5$ خواهد بود. برای تقسیم صحیح همچنان می‌توان از $5 // 2 = 2$ استفاده کرد.

توابع (Functions)

تعریف تابع

تابع یک قاعده است که صفر یا چند ورودی دریافت کرده و خروجی مشخصی را برمی‌گرداند. در پایتون، ما یک تابع را با def function_name(parameters) تعریف می‌کنیم:

def double(x):
    """شما می‌توانید در اینجا توضیحات مربوط به عملکرد تابع را بنویسید.
    برای مثال، این تابع ورودی را در ۲ ضرب می‌کند."""
    # بدنه اصلی تابع در اینجا نوشته می‌شود، تورفتگی را فراموش نکنید.
    return x * 2

استفاده از تابع

در پایتون، توابع “first-class citizens” محسوب می‌شوند، به این معنی که می‌توانیم آن‌ها را به یک متغیر اختصاص دهیم و یا به عنوان آرگومان به توابع دیگر ارسال کنیم:

def apply_to_one(f):
    """تابع f را فراخوانی کرده و ۱ را به عنوان پارامتر به آن ارسال می‌کند"""
    return f(1)
my_double = double          # double به تابعی که در بخش قبل تعریف شد، اشاره می‌کند
x = apply_to_one(my_double) # x برابر با ۲ است

توابع بی‌نام (Anonymous Functions)

همچنین می‌توان توابع بی‌نام (anonymous functions) را با استفاده از lambda ایجاد کرد:

y = apply_to_one(lambda x: x + 4)     # برابر با ۵ است

می‌توان lambda را به متغیرهای دیگر اختصاص داد، اما بیشتر افراد توصیه می‌کنند که تا حد امکان از def استفاده کنید:

another_double = lambda x: 2 * x      # توصیه نمی‌شود
def another_double(x): return 2 * x   # روش توصیه شده

نکات تکمیلی:

• lambda تنها یک عبارت (expression) است و بدنه تابع آن بسیار ساده‌تر از def است.
• بدنه اصلی lambda یک عبارت است، نه یک بلوک کد. تنها می‌توان منطق محدودی را در عبارت lambda گنجاند.

ارسال پارامتر به تابع

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

def my_print(message="my default message"):
    print message
my_print("hello")     # خروجی "hello"
my_print()            # خروجی "my default message"

گاهی اوقات، تعیین پارامترها مستقیماً با نام آن‌ها نیز بسیار کارآمد است:

def subtract(a=0, b=0):
    return a - b
subtract(10, 5)   # خروجی ۵
subtract(0, 5)    # خروجی -۵
subtract(b=5)     # مانند حالت قبل، خروجی -۵

رشته‌ها (Strings)

می‌توانید برای ایجاد رشته‌ها از نقل قول تکی یا دوتایی استفاده کنید (حتماً باید جفت باشند):

single_quoted_string = 'data science'
double_quoted_string = "data science"

از بک‌اسلش برای نمایش کاراکترهای فرار (escape characters) استفاده می‌شود، مانند:

tab_string = "\t"      # نشان‌دهنده کاراکتر تب
len(tab_string)        # برابر با ۱ است

هنگامی که می‌خواهید خود بک‌اسلش را استفاده کنید (مثلاً برای مسیرهای ویندوز یا عبارات منظم)، می‌توانید با استفاده از رشته‌های خام (r"") آن را تعریف کنید:

not_tab_string = r"\t" # نشان‌دهنده کاراکترهای '\' و 't'
len(not_tab_string)    # برابر با ۲ است

برای ایجاد رشته‌های چندخطی، از سه نقل قول دوتایی استفاده کنید:

multi_line_string = """این خط اول است
این خط دوم است
این خط سوم است"""

مدیریت خطا (Exception Handling)

هنگامی که برنامه‌ای با خطا مواجه می‌شود، پایتون یک استثنا (exception) ایجاد می‌کند. اگر این استثنا را مدیریت نکنیم، برنامه متوقف خواهد شد. برای مدیریت استثناها می‌توان از دستورات try و except استفاده کرد:

try:
    print 0 / 0
except ZeroDivisionError:
    print "نمی‌توان بر ۰ تقسیم کرد"

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

لیست‌ها (Lists)

ایجاد لیست

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

integer_list = [1, 2, 3]
heterogeneous_list = ["string", 0.1, True]
list_of_lists = [ integer_list, heterogeneous_list, [] ]
list_length = len(integer_list)   # برابر با ۳ است
list_sum = sum(integer_list)      # برابر با ۶ است

دسترسی به مقادیر لیست

می‌توانید با استفاده از نمایه (index) در کروشه به مقادیر لیست دسترسی پیدا کنید:

x = range(10)       # لیست x = [0, 1, ..., 9] را ایجاد می‌کند
zero = x[0]         # برابر با ۰ است، شماره‌گذاری لیست از ۰ شروع می‌شود
one = x[1]          # برابر با ۱ است
nine = x[-1]        # برابر با ۹ است، آخرین عنصر لیست
eight = x[-2]       # برابر با ۸ است، دومین عنصر از آخر لیست
x[0] = -1           # اکنون لیست x = [-1, 1, 2, 3, ..., 9] است

برش لیست (Slicing)

می‌توانید با استفاده از کروشه، لیست را برش دهید:

first_three = x[:3]                  # [-1, 1, 2]
three_to_end = x[3:]                 # [3, 4, ..., 9]
one_to_four = x[1:5]                 # [1, 2, 3, 4]
last_three = x[-3:]                  # [7, 8, 9]
without_first_and_last = x[1:-1]     # [1, 2, ..., 8]
copy_of_x = x[:]                     # [-1, 1, 2, ..., 9]

می‌توانید از in برای بررسی وجود یک عنصر در لیست استفاده کنید:

1 in [1, 2, 3]        # True
0 in [1, 2, 3]        # False

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

الحاق لیست‌ها (Concatenating)

در پایتون، به راحتی می‌توان دو لیست را به هم الحاق (concatenate) کرد:

x = [1, 2, 3]
x.extend([4, 5, 6])   # اکنون x = [1,2,3,4,5,6] است

اگر نمی‌خواهید لیست اصلی x را تغییر دهید، می‌توانید با استفاده از عملگر “جمع” یک لیست جدید ایجاد کنید:

x = [1, 2, 3]
y = x + [4, 5, 6]     # اکنون y = [1, 2, 3, 4, 5, 6] است؛ x تغییر نکرده است

اغلب برای اضافه کردن یک عنصر به لیست، از این روش استفاده می‌شود:

x = [1, 2, 3]
x.append(0)           # اکنون x = [1, 2, 3, 0] است
y = x[-1]             # برابر با ۰ است
z = len(x)            # برابر با ۴ است

تجزیه لیست (List Unpacking)

اگر تعداد عناصر لیست را می‌دانید، می‌توانید به راحتی آن را تجزیه کنید:

x, y = [1, 2]         # اکنون x = 1, y = 2 است

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

_, y = [1, 2]         # اکنون y == 2 است، عنصر اول نادیده گرفته می‌شود

تاپل‌ها (Tuples)

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

ایجاد تاپل

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

my_tuple = (1, 2)
other_tuple = 3, 4
my_list[1] = 3        # اکنون my_list برابر با [1, 3] است
try:
    my_tuple[1] = 3
except TypeError:
    print "نمی‌توان تاپل را تغییر داد"

تاپل‌ها راهی بسیار مناسب برای بازگرداندن چندین مقدار از یک تابع هستند:

def sum_and_product(x, y):
    return (x + y),(x * y)
sp = sum_and_product(2, 3)    # برابر با (5, 6) است
s, p = sum_and_product(5, 10) # s = 15, p = 50

تاپل‌ها (و لیست‌ها) هر دو از تخصیص همزمان چندین عنصر پشتیبانی می‌کنند:

x, y = 1, 2       # اکنون x = 1, y = 2 است
x, y = y, x       # جابجایی مقادیر دو متغیر در پایتون؛ اکنون x = 2, y = 1 است

دیکشنری‌ها (Dictionaries)

ایجاد دیکشنری

یکی دیگر از ساختارهای داده اساسی در پایتون، دیکشنری است که به شما امکان می‌دهد با استفاده از کلید (key) به سرعت به مقدار (value) مربوطه دسترسی پیدا کنید:

empty_dict = {}                       # تعریف دیکشنری خالی به شیوه بسیار "پایتونی"
empty_dict2 = dict()                  # تعریف دیکشنری خالی به شیوه "کمتر پایتونی"
grades = { "Joel" : 80, "Tim" : 95 }  # ذخیره نمرات

جستجوی عناصر دیکشنری

می‌توانید با استفاده از کروشه و کلید، مقدار مربوطه را جستجو کنید:

joels_grade = grades["Joel"]          # برابر با ۸۰ است

اگر کلیدی که به دنبال آن هستید در دیکشنری موجود نباشد، یک خطای KeyError بازگردانده خواهد شد:

try:
    kates_grade = grades["Kate"]
except KeyError:
    print "نمره‌ای برای Kate وجود ندارد!"

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

joel_has_grade = "Joel" in grades     # True
kate_has_grade = "Kate" in grades     # False

دیکشنری متدی دارد که در صورت عدم وجود کلید مورد نظر، یک مقدار پیش‌فرض را برمی‌گرداند (به جای ایجاد استثنا):

joels_grade = grades.get("Joel", 0)   # برابر با ۸۰ است
kates_grade = grades.get("Kate", 0)   # برابر با ۰ است
no_ones_grade = grades.get("No One")  # مقدار پیش‌فرض None را برمی‌گرداند

تغییر دیکشنری

می‌توانید با استفاده از کروشه، جفت‌های کلید-مقدار را در دیکشنری ایجاد یا تغییر دهید:

grades["Tim"] = 99                    # جایگزینی مقدار قدیمی
grades["Kate"] = 100                  # اضافه کردن یک جفت کلید-مقدار جدید
num_students = len(grades)            # برابر با ۳ است

اغلب اوقات، ما از دیکشنری‌ها به این شکل برای نمایش ساختار داده‌ها استفاده خواهیم کرد:

tweet = {
    "user" : "joelgrus",
    "text" : "Data Science is Awesome",
    "retweet_count" : 100,
    "hashtags" : ["#data", "#science", "#datascience", "#awesome", "#yolo"]
}

علاوه بر جستجوی یک کلید خاص، می‌توانیم تمام کلیدها را به این شکل مدیریت کنیم:

tweet_keys = tweet.keys()             # یک لیست از کلیدها را برمی‌گرداند
tweet_values = tweet.values()         # یک لیست از مقادیر را برمی‌گرداند
tweet_items = tweet.items()           # یک تاپل از (کلید, مقدار) را برمی‌گرداند
"user" in tweet_keys                  # True را برمی‌گرداند، از جستجوی 'in' که در لیست‌ها کارآمد نیست استفاده می‌کند
"user" in tweet                       # روش "پایتونی"‌تر، از جستجوی کارآمد 'in' در دیکشنری استفاده می‌کند
"joelgrus" in tweet_values            # True

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

دیکشنری پیش‌فرض (Defaultdict)

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

word_counts = {}
for word in document:
    if word in word_counts:
        word_counts[word] += 1
    else:
        word_counts[word] = 1

البته، می‌توانید یک کلید از دست رفته را با استفاده از رویکرد “اول سعی کن، بعد مدیریت کن” (EAFP - Easier to Ask Forgiveness than Permission) به این شکل مدیریت کنید:

word_counts = {}
for word in document:
    try:
        word_counts[word] += 1
    except KeyError:
        word_counts[word] = 1

روش سوم، استفاده از متد get است که برای مدیریت کلیدهای از دست رفته عملکرد بسیار خوبی دارد:

word_counts = {}
for word in document:
    previous_count = word_counts.get(word, 0)
    word_counts[word] = previous_count + 1

دیکشنری پیش‌فرض (defaultdict) دقیقاً مانند یک دیکشنری معمولی است، با این تفاوت که وقتی شما سعی می‌کنید به یک کلید ناموجود دسترسی پیدا کنید، به طور خودکار با استفاده از یک مقدار پیش‌فرض (که شما تعیین می‌کنید) یک جفت کلید-مقدار جدید ایجاد می‌کند. برای استفاده از آن، باید کتابخانه collections را وارد کنید:

from collections import defaultdict
word_counts = defaultdict(int)        # int() عدد ۰ را تولید می‌کند
for word in document:
    word_counts[word] += 1

دیکشنری پیش‌فرض در کنار لیست‌ها، دیکشنری‌های معمولی و حتی توابع سفارشی، بسیار کاربردی است:

dd_list = defaultdict(list)           # list() یک لیست خالی تولید می‌کند
dd_list[2].append(1)                  # اکنون dd_list برابر با {2: [1]} است
dd_dict = defaultdict(dict)           # dict() یک دیکشنری خالی تولید می‌کند
dd_dict["Joel"]["City"] = "Seattle"   # اکنون محتوای dd_dict برابر با { "Joel" : { "City" : Seattle"}} است
dd_pair = defaultdict(lambda: [0, 0]) # یک دیکشنری با مقادیر لیستی برای کلیدها ایجاد می‌کند
dd_pair[2][1] = 1                     # اکنون محتوای dd_pair برابر با {2: [0,1]} است

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

شمارنده (Counter)

شمارنده (Counter) می‌تواند مستقیماً مجموعه‌ای از مقادیر را به یک شیء شبیه دیکشنری تبدیل کند، که در آن کلیدها عناصر مجموعه و مقادیر، تعداد دفعات تکرار آن عناصر هستند. این قابلیت اغلب هنگام ایجاد هیستوگرام‌ها کاربرد دارد:

from collections import Counter
c = Counter([0, 1, 2, 0]) # c (تقریباً) برابر با { 0 : 2, 1 : 1, 2 : 1 } است

به این ترتیب، ما یک روش بسیار راحت برای شمارش فرکانس کلمات در اختیار داریم:

word_counts = Counter(document)

شمارنده همچنین یک متد بسیار پرکاربرد به نام most_common دارد که مستقیماً کلمات با بالاترین فرکانس و تعداد تکرار آن‌ها را برمی‌گرداند:

# ۱۰ کلمه با بیشترین تکرار و تعداد آن‌ها را چاپ می‌کند
for word, count in word_counts.most_common(10):
    print word, count

مجموعه‌ها (Sets)

یکی دیگر از ساختارهای داده در پایتون، مجموعه (set) است. مجموعه، گردایه‌ای از عناصر متمایز است. می‌توانید به این صورت یک مجموعه ایجاد کرده و عناصر را به آن اضافه کنید:

s = set()
s.add(1)          # s برابر با { 1 } است
s.add(2)          # s برابر با { 1, 2 } است
s.add(2)          # s برابر با { 1, 2 } است
x = len(s)        # برابر با ۲ است
y = 2 in s        # برابر با True است
z = 3 in s        # برابر با False است

دو دلیل اصلی برای استفاده از مجموعه‌ها:

اولاً، عملیات in در مجموعه‌ها بسیار کارآمد است. هنگامی که تعداد عناصر در یک مجموعه داده بسیار زیاد باشد، جستجوی عناصر به شکل مجموعه به وضوح مناسب‌تر از لیست است:

stopwords_list = ["a","an","at"] + hundreds_of_other_words + ["yet", "you"]
"zip" in stopwords_list               # ناموفق، نیاز به بررسی هر عنصر دارد
stopwords_set = set(stopwords_list)
"zip" in stopwords_set                # جستجو موفقیت‌آمیز و بسیار سریع است

ثانیاً، استفاده از مجموعه برای به دست آوردن عناصر متمایز از یک مجموعه داده بسیار راحت است:

item_list = [1, 2, 3, 1, 2, 3]
num_items = len(item_list)            # ۶
item_set = set(item_list)             # {1, 2, 3}
num_distinct_items = len(item_set)    # ۳
distinct_item_list = list(item_set)   # [1, 2, 3]

اما در عمل، فراوانی استفاده از مجموعه‌ها همچنان کمتر از دیکشنری‌ها و لیست‌ها است.

دستورات شرطی

در اکثر زبان‌های برنامه‌نویسی، می‌توانید از if به این شکل برای بیان شاخه‌های شرطی استفاده کنید:

if 1 > 2:
    message = "کاش ۱ بزرگ‌تر از ۲ بود…"
elif 1 > 3:
    message = "elif مخفف 'else if' است"
else:
    message = "وقتی همه چیز شکست می‌خورد از else استفاده کنید (اگر می‌خواهید)"

می‌توانید دستورات شرطی را به این شکل در یک خط بنویسید، اما این روش کمتر رایج است:

parity = "even" if x % 2 == 0 else "odd"

دستورات حلقوی

حلقه while

حلقه while در پایتون:

x = 0
while x < 10:
    print x, "کمتر از ۱۰ است"
    x += 1

حلقه for

رایج‌تر استفاده از حلقه for-in است:

for x in range(10):
    print x, "کمتر از ۱۰ است"

در عبارات منطقی پیچیده‌تر، می‌توان از دستورات continue و break استفاده کرد:

for x in range(10):
    if x == 3:
        continue          # مستقیماً به دور بعدی حلقه می‌رود
    if x == 5:
        break             # کاملاً از حلقه خارج می‌شود
    print x

نتیجه، چاپ اعداد ۰، ۱، ۲، و ۴ خواهد بود.

درستی (Truthiness)

متغیرهای بولی (Booleans) در پایتون تقریباً مانند سایر زبان‌ها هستند؛ تنها تفاوت این است که حرف اول آن‌ها باید همیشه با حروف بزرگ نوشته شود:

one_is_less_than_two = 1 < 2      # برابر با True است
true_equals_false = True == False # برابر با False است

پایتون از None برای نشان دادن عدم وجود یک مقدار استفاده می‌کند، که مشابه null در سایر زبان‌ها است:

x = None
print x == None        # خروجی True است، اما به اندازه کافی زیبا نیست
print x is None        # خروجی True است، روش زیباتر

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

• False
• None
• [] (یک لیست خالی)
• {} (یک دیکشنری خالی)
• “”
• set()
• 0
• 0.0

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

البته، اگر نتوانید نتیجه را پیش‌بینی کنید، ممکن است در حین استفاده با مشکل مواجه شوید:

s = some_function_that_returns_a_string()
if s:
    first_char = s[0]
else:
    first_char = ""

یک روش ساده‌تر که اثری معادل روش بالا دارد:

first_char = s and s[0]

اگر اولین مقدار درست باشد، مقدار دوم بازگردانده می‌شود؛ در غیر این صورت، مقدار اول بازگردانده خواهد شد.

به طور مشابه، اگر x ممکن است یک عدد باشد یا None، با این روش می‌توانید مطمئن شوید که x یک عدد است:

safe_x = x or 0

در پایتون، تابع all وجود دارد که اگر تمامی عناصر True باشند، True را برمی‌گرداند. تابع any نیز اگر حداقل یک عنصر True باشد، True را برمی‌گرداند. برای مثال، برای لیستی که تمامی عناصر آن “درست” هستند، تابع all مقدار True را بازمی‌گرداند، در غیر این صورت False را برمی‌گرداند:

all([True, 1, { 3 }])       # True
all([True, 1, {}])          # False، {} معادل "False" است
any([True, 1, {}])          # True
all([])                     # True، هیچ عنصری معادل "False" وجود ندارد
any([])                     # False، هیچ عنصری معادل "True" وجود ندارد

مطالعه بیشتر: دستور زبان رایج پایتون در علم داده (پیشرفته)