मैं ज्यादातर पायथन के साथ काम करता हूं और लगभग दैनिक आधार पर कोड की समीक्षा करता हूं। हमारे कोड में बेस फ़ॉर्मेटिंग और लिंटिंग को सीआई जॉब्स द्वारा ब्लैक एंड माइपी का उपयोग करके नियंत्रित किया जाता है। इसलिए, हम केवल बदलावों पर ध्यान केंद्रित करते हैं।

किसी टीम में काम करते समय, आप पहले से ही जानते हैं कि किसी निश्चित टीम के सदस्य से किस प्रकार के कोड की अपेक्षा की जानी चाहिए। जब कोई नया व्यक्ति टीम में शामिल होता है तो कोड समीक्षाएँ दिलचस्प हो जाती हैं। मैं दिलचस्प कहता हूं, क्योंकि हर किसी की कुछ कोडिंग शैली होती है जिसका उपयोग वे अनजाने में करते हैं; अच्छे या बुरे के लिए! जैसे मेरे पास कुछ है,

1. वैकल्पिक प्रकार का मान सेट करना। आम तौर पर ये चर हस्ताक्षर का हिस्सा होते हैं

# I used (long back) to do

def func(a: int, b: Optional[list] = None, c: Optional[Dict] = None):

    if b is None:
       b = []
    if c is None:
       c = {}

# Instead I do

def func(a: int, b: Optional[list] = None, c: Optional[Dict] = None):

    b = b or []
    c = c or {}

1. सरल if..elif..else (3-4 तक) कथनों को तानाशाही के साथ संभालना

यह सरल उपयोग का मामला है जहां आप एक स्ट्रिंग लौटाते हैं या कुछ मान के आधार पर फ़ंक को कॉल करते हैं

नोट: 3.10 से आपको इसके बजाय मैच का उपयोग करना चाहिए।

करने के बजाय,

def get_number_of_wheels(vehicle: str):
    if vehicle == "car":
        wheels = 2
    elif vehicle == "bus":
        wheels = 6
    elif vehicle == "bicycle":
        wheels = 2
    else:
        raise ...

# I prefer doing, 

def get_number_of_wheels(vehicle: str):
    return {
       "car": 2,
       "bus": 6,
       "bicycle": 2
    }[vehicle]       # Raise is now KeyError

ऊपर कुछ उदाहरण दिए गए हैं, जो लोग मेरे कोड की समीक्षा करेंगे उनके पास और भी उदाहरण होंगे।

हाल ही में, एक नया डेवलपर मेरी टीम में शामिल हुआ और मैंने एक पैटर्न देखा जो मुझे पसंद आया लेकिन मैंने इसे सरल यदि..अन्यथा मामले में बदलने के लिए कहा। मैं पहले आपको पैटर्न दिखाऊंगा फिर बदलाव मांगने का कारण बताऊंगा।

कोड एक डेकोरेटर है जो मापदंडों के लिए कुछ करता है। आइए एक सरल (बेकार) डेकोरेटर लिखें जो उस फ़ंक्शन/विधि से कॉल किए गए आर्ग और क्वार्ग की संख्या प्रिंट करेगा।

def counter(is_cls_method: bool = False):
    """ print number of args & kwargs for func/method """
    def outer(f):
        def inner(*args, **kwargs):
            args_cnt = len(args)
            kwargs_cnt = len(kwargs)
            print(f"{f.__name__} called with {args_cnt=} & {kwargs_cnt=}")
            return f(*args, **kwargs)
        return inner
    return outer

@counter()
def test1(a, b, c):
    pass

class A:
    @counter(is_cls_method=True)
    def test1(self, a, b, c):
        pass


print("function")
test1(1, 2, c=3)
test1(a=1, b=2, c=3)

print("method")
a = A()
a.test1(1, 2, 3)
a.test1(1, b=2, c=3)

इस कोड को चलाने पर, आपको देखना चाहिए

function
test1 called with args_cnt=2 & kwargs_cnt=1
test1 called with args_cnt=0 & kwargs_cnt=3

method
test1 called with args_cnt=4 & kwargs_cnt=0
test1 called with args_cnt=2 & kwargs_cnt=2

यह ठीक काम कर रहा है लेकिन तरीकों के लिए, यह स्वयं की गिनती भी कर रहा है। तो चलिए इसे ठीक करते हैं!

def counter(is_cls_method: bool = False):
    def outer(f):
        def inner(*args, **kwargs):
            args_cnt = len(args)

            if is_cls_method:   # Check added
               args_cnt -= 1    # Reduced count by 1

            kwargs_cnt = len(kwargs)
            print(f"{f.__name__} called with {args_cnt=} & {kwargs_cnt=}")
            return f(*args, **kwargs)
        return inner
    return outer

यह एक सरल यदि खंड है, लेकिन नए डेवलपर ने कुछ और किया जो बूलियन का दिलचस्प उपयोग था।

मैं केवल बदला हुआ कोड दिखा रहा हूं...

   args_cnt = len(args[is_cls_method:])

अगर का उपयोग करने की तुलना में समाधान बहुत बेहतर है, क्योंकि पायथन में बूल सिर्फ इंट है। मूल कोड थोड़ा लंबा था और इस छोटे से बदलाव पर ध्यान देना स्पष्ट नहीं है, कोड बेस का उपयोग उन उपयोगकर्ताओं द्वारा भी किया जाता है जो मूल पायथन उपयोगकर्ता हैं। और, यदि आपको यह अनुमान लगाना है कि एक पंक्ति क्या कर रही है, तो मुझे लगता है कि आपको इसे स्पष्ट करने के लिए बदलना चाहिए।

इस पर आपका क्या विचार है, क्या आप बूलियन को सूचकांक के रूप में उपयोग करते हैं?
क्या आपके पास इस तरह का कोई और पायथन पैटर्न है?