പൈത്തൺ തരം ചെക്കർ താരതമ്യം: ശൂന്യമായ കണ്ടെയ്നർ അനുമാനം

എന്തുകൊണ്ടാണ് ശൂന്യമായ കണ്ടെയ്‌നറുകൾ പൈത്തൺ തരം ചെക്കറുകൾ തകർക്കുന്നത് - അതിനെക്കുറിച്ച് നിങ്ങൾക്ക് എന്തുചെയ്യാൻ കഴിയും

2015-ൽ PEP 484 ടൈപ്പ് സൂചനകൾ അവതരിപ്പിച്ചതിന് ശേഷം പൈത്തണിൻ്റെ ക്രമാനുഗതമായ ടൈപ്പിംഗ് സിസ്റ്റം ഗണ്യമായി പക്വത പ്രാപിച്ചു. ഇന്ന്, ദശലക്ഷക്കണക്കിന് ഡെവലപ്പർമാർ, ഉൽപ്പാദനത്തിൽ എത്തുന്നതിന് മുമ്പ് ബഗുകൾ പിടിക്കാൻ സ്റ്റാറ്റിക് ടൈപ്പ് ചെക്കറുകളെ ആശ്രയിക്കുന്നു. പക്ഷേ, പരിചയസമ്പന്നരായ എഞ്ചിനീയർമാരെപ്പോലും ഇപ്പോഴും ട്രിപ്പ് ചെയ്യുന്ന ടൈപ്പ് സിസ്റ്റത്തിൻ്റെ സൂക്ഷ്മവും നിരാശാജനകവുമായ ഒരു കോണുണ്ട്: ഒരു ശൂന്യമായ കണ്ടെയ്നറിന് ഏത് തരം ഉണ്ട്? വ്യാഖ്യാനമില്ലാതെ നിങ്ങൾ x = [] എഴുതുമ്പോൾ, നിങ്ങളുടെ ടൈപ്പ് ചെക്കർ ഊഹിക്കേണ്ടതുണ്ട് - വ്യത്യസ്ത ചെക്കറുകൾ വ്യത്യസ്തമായി ഊഹിക്കുന്നു. ഈ വ്യതിചലനം വലിയ കോഡ്ബേസുകൾ പരിപാലിക്കുന്ന ടീമുകൾക്ക് യഥാർത്ഥ പ്രശ്‌നങ്ങൾ സൃഷ്ടിക്കുന്നു, ഇവിടെ തരം ചെക്കറുകൾ മാറുകയോ സംയോജിപ്പിക്കുകയോ ചെയ്യുന്നത് ഒറ്റരാത്രികൊണ്ട് നൂറുകണക്കിന് അപ്രതീക്ഷിത പിശകുകൾ സൃഷ്ടിക്കും.

4 പ്രധാന പൈത്തൺ തരം ചെക്കറുകൾ - mypy, pyright, pytype, pyre - എങ്ങനെ ശൂന്യമായ കണ്ടെയ്‌നർ അനുമാനം കൈകാര്യം ചെയ്യുന്നു, എന്തുകൊണ്ട് അവർ വിയോജിക്കുന്നു, നിങ്ങളുടെ ടൂളിംഗ് ചോയ്‌സ് പരിഗണിക്കാതെ തന്നെ ടൈപ്പ്-സേഫ് പൈത്തൺ എഴുതാൻ നിങ്ങൾക്ക് എന്ത് പ്രായോഗിക തന്ത്രങ്ങൾ സ്വീകരിക്കാം എന്നിവ ഈ ലേഖനം വിശദീകരിക്കുന്നു.

പ്രധാന പ്രശ്നം: ശൂന്യമായ പാത്രങ്ങൾ അന്തർലീനമായി അവ്യക്തമാണ്

പൈത്തണിൻ്റെ ഈ നിരുപദ്രവകരമായ ലൈൻ പരിഗണിക്കുക: ഫലങ്ങൾ = []. ഫലങ്ങൾ ഒരു ലിസ്റ്റ്[int] ആണോ? ഒരു ലിസ്റ്റ്[str]? ഒരു list[dict[str, Any]]? അധിക സന്ദർഭം കൂടാതെ, യഥാർത്ഥമായി അറിയാൻ ഒരു മാർഗവുമില്ല. പൈത്തൺ റൺടൈം കാര്യമാക്കുന്നില്ല - ലിസ്റ്റുകൾ സ്വഭാവമനുസരിച്ച് വൈവിധ്യമാർന്നതാണ് - എന്നാൽ സ്റ്റാറ്റിക് ടൈപ്പ് ചെക്കറുകൾക്ക് അവരുടെ ജോലി ചെയ്യുന്നതിന് ഓരോ വേരിയബിളിനും ഒരു കോൺക്രീറ്റ് തരം നൽകേണ്ടതുണ്ട്. ഇത് പൈത്തണിൻ്റെ ഡൈനാമിക് ഫ്ലെക്സിബിലിറ്റിയും സ്റ്റാറ്റിക് അനാലിസിസ് നൽകാൻ ശ്രമിക്കുന്ന ഗ്യാരണ്ടിയും തമ്മിൽ ഒരു അടിസ്ഥാന പിരിമുറുക്കം സൃഷ്ടിക്കുന്നു.

നിഘണ്ടുക്കളിലും സെറ്റുകളിലും പ്രശ്‌നം സംയോജിപ്പിക്കുന്നു. ഒരു ശൂന്യമായ {} യഥാർത്ഥത്തിൽ ഒരു ഡിക്റ്റ് ആയി പാഴ്‌സ് ചെയ്‌തിരിക്കുന്നു, ഒരു സെറ്റ് അല്ല, ഇത് ടൈപ്പ്-ലെവൽ അവ്യക്തതയ്‌ക്ക് മുകളിൽ വാക്യഘടന അവ്യക്തത ചേർക്കുന്നു. കൂടാതെ നെസ്റ്റഡ് കണ്ടെയ്‌നറുകൾ — defaultdict(list) അല്ലെങ്കിൽ results = {k: [] കീകളിൽ k എന്നതിന്} — ചിന്തിക്കുക — അനുമാന എഞ്ചിനുകളെ അവയുടെ പരിധിയിലേക്ക് തള്ളുക. ഓരോ തരം ചെക്കറും അതിൻ്റേതായ ഹ്യൂറിസ്റ്റിക്സ് വികസിപ്പിച്ചെടുത്തിട്ടുണ്ട്, മാത്രമല്ല മിക്ക ഡെവലപ്പർമാരും മനസ്സിലാക്കുന്നതിനേക്കാൾ വ്യത്യാസങ്ങൾ വളരെ പ്രധാനമാണ്.

യഥാർത്ഥ ജോലിഭാരങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്ന പ്രൊഡക്ഷൻ സിസ്റ്റങ്ങളിൽ - അത് ഉപഭോക്തൃ രേഖകൾ കൈകാര്യം ചെയ്യുന്ന ഒരു CRM ആണെങ്കിലും, ലൈൻ ഇനങ്ങൾ സൃഷ്ടിക്കുന്ന ഒരു ഇൻവോയ്സിംഗ് മൊഡ്യൂളായാലും അല്ലെങ്കിൽ ഒരു അനലിറ്റിക്സ് പൈപ്പ്ലൈൻ അഗ്രഗേറ്റ് ചെയ്യുന്ന അളവുകളായാലും - ശൂന്യമായ കണ്ടെയ്നറുകൾ സമാരംഭിക്കൽ പാറ്റേണുകളായി നിരന്തരം ദൃശ്യമാകും. അവയുടെ തരങ്ങൾ തെറ്റിദ്ധരിക്കുന്നത് കേവലം അപായ മുന്നറിയിപ്പുകൾ മാത്രമല്ല; റൺടൈമിലേക്ക് കടന്നുപോകുന്ന യഥാർത്ഥ ബഗുകൾ മറയ്ക്കാൻ ഇതിന് കഴിയും.

Mypy: എന്തെങ്കിലും പരോക്ഷമായി മാറ്റിവെച്ച അനുമാനം

പൈത്തൺ ടൈപ്പ് ചെക്കറായ മൈപ്പി, ഏറ്റവും പഴക്കമേറിയതും വ്യാപകമായി സ്വീകരിച്ചിട്ടുള്ളതും, ശൂന്യമായ കണ്ടെയ്‌നറുകളോട് താരതമ്യേന സൗമ്യമായ സമീപനമാണ് സ്വീകരിക്കുന്നത്. ഫംഗ്‌ഷൻ സ്കോപ്പിൽ അത് x = [] നേരിടുമ്പോൾ, അത് തരം തീരുമാനം മാറ്റിവയ്ക്കാനും തുടർന്നുള്ള ഉപയോഗത്തിൽ നിന്ന് മൂലക തരം അനുമാനിക്കാനും ശ്രമിക്കുന്നു. നിങ്ങൾ x = [] എന്നതിന് ശേഷം x.append(42) എഴുതുകയാണെങ്കിൽ, mypy list[int] അനുമാനിക്കും. ഈ "ചേരുക" തന്ത്രം, കണ്ടെയ്‌നർ ഒരേ പരിധിക്കുള്ളിൽ ജനവാസമുള്ള നേരായ സന്ദർഭങ്ങളിൽ അത്ഭുതകരമാംവിധം നന്നായി പ്രവർത്തിക്കുന്നു.

എന്നിരുന്നാലും, മൈപിയുടെ സ്വഭാവം സന്ദർഭവും കർശന ക്രമീകരണങ്ങളും അനുസരിച്ച് നാടകീയമായി മാറുന്നു. മൊഡ്യൂൾ സ്കോപ്പിൽ (ടോപ്പ്-ലെവൽ കോഡ്), അല്ലെങ്കിൽ കണ്ടെയ്നർ പോപ്പുലേറ്റ് ചെയ്യപ്പെടുന്നതിന് മുമ്പ് മറ്റൊരു ഫംഗ്ഷനിലേക്ക് കൈമാറുമ്പോൾ, mypy പലപ്പോഴും ലിസ്റ്റ്[ഏതെങ്കിലും] എന്നതിലേക്ക് മടങ്ങുന്നു. -- കർശനമായ ഫ്ലാഗിന് കീഴിൽ, ഇത് ഒരു പിശക് ട്രിഗർ ചെയ്യുന്നു, എന്നാൽ സ്ഥിരസ്ഥിതി മോഡിൽ അത് നിശബ്ദമായി കടന്നുപോകുന്നു. ഇതിനർത്ഥം, കർശനമായ മോഡ് ഇല്ലാതെ mypy പ്രവർത്തിക്കുന്ന ടീമുകൾക്ക്, അതിൻ്റെ ഉദ്ദേശ്യത്തെ പരാജയപ്പെടുത്തി, ടൈപ്പ് സിസ്റ്റത്തിൽ നിന്ന് രക്ഷപ്പെടാൻ കഴിയുന്ന ഡസൻ കണക്കിന് പരോക്ഷമായി-ടൈപ്പ് ചെയ്ത കണ്ടെയ്‌നറുകൾ ശേഖരിക്കാനാകും.

പ്രത്യേകിച്ച് സൂക്ഷ്മമായ ഒരു പെരുമാറ്റം: 0.990-ന് മുമ്പുള്ള mypy പതിപ്പുകൾ ചിലപ്പോൾ ലിസ്റ്റ്[അജ്ഞാതം] ആന്തരികമായി അനുമാനിക്കുകയും തുടർന്ന് അസൈൻമെൻ്റിൽ ലിസ്റ്റ്[ഏതെങ്കിലും] എന്നതിലേക്ക് വികസിപ്പിക്കുകയും ചെയ്യും. 0.990-ന് ശേഷം, അനുമാനം കർശനമാക്കി, എന്നാൽ ഈ മാറ്റം, അത് തിരിച്ചറിയാതെ തന്നെ അനുവദനീയമായ പെരുമാറ്റത്തെ ആശ്രയിച്ചിരുന്ന യഥാർത്ഥ ലോക കോഡ്ബേസുകളുടെ അതിശയിപ്പിക്കുന്ന എണ്ണം തകർത്തു. ഇതൊരു ആവർത്തിച്ചുള്ള തീം ആണ് — പാറ്റേണുകൾ സർവവ്യാപിയായതിനാൽ ശൂന്യമായ കണ്ടെയ്‌നർ അനുമാനത്തിലേക്കുള്ള മാറ്റങ്ങൾ ഏറ്റവും തടസ്സപ്പെടുത്തുന്ന തരത്തിലുള്ള ചെക്കർ അപ്‌ഡേറ്റുകളിൽ ഒന്നാണ്.

പൈറൈറ്റ്: കർശനമായ അനുമാനവും "അജ്ഞാത" തരവും

പൈറൈറ്റ്, മൈക്രോസോഫ്റ്റ് വികസിപ്പിച്ചതും വിഎസ് കോഡിൽ പൈലൻസ് പവർ ചെയ്യുന്നതും അടിസ്ഥാനപരമായി വ്യത്യസ്തമായ ഒരു ദാർശനിക നിലപാട് സ്വീകരിക്കുന്നു. ഏതെങ്കിലും എന്നതിലേക്ക് നിശബ്ദമായി പിന്മാറുന്നതിനുപകരം, പൈറൈറ്റ് അജ്ഞാത (ഇതുവരെ നിർണ്ണയിച്ചിട്ടില്ലാത്ത ഒരു തരം), ഏതെങ്കിലും (തരം പരിശോധനയിൽ നിന്ന് വ്യക്തമായ ഒഴിവാക്കൽ) എന്നിവ തമ്മിൽ വേർതിരിച്ചറിയുന്നു. നിങ്ങൾ x = [] പൈറൈറ്റിൻ്റെ കർശനമായ മോഡിൽ എഴുതുമ്പോൾ, അത് ലിസ്റ്റ്[അജ്ഞാതം] അനുമാനിക്കുകയും ഒരു ഡയഗ്നോസ്റ്റിക് റിപ്പോർട്ടുചെയ്യുകയും, ഒരു വ്യാഖ്യാനം നൽകാൻ നിങ്ങളെ നിർബന്ധിക്കുകയും ചെയ്യുന്നു.

പൈറൈറ്റ് പരിധിക്കുള്ളിൽ ഇടുങ്ങിയതിലും കൂടുതൽ ആക്രമണാത്മകമാണ്. നിങ്ങൾ എഴുതുകയാണെങ്കിൽ:

• x = [] തുടർന്ന് x.append("hello") — പൈറൈറ്റ് അനുമാനിക്കുന്നത് list[str]
• x = [] തുടർന്ന് x.append(1) തുടർന്ന് x.append("hello") — pyright infers list[int | str]
• x = [] നേരിട്ട് list[int] പ്രതീക്ഷിക്കുന്ന ഒരു ഫംഗ്‌ഷനിലേക്ക് കടന്നുപോയി - കോൾ-സൈറ്റ് സന്ദർഭത്തിൽ നിന്ന് പൈറൈറ്റ് list[int] അനുമാനിക്കുന്നു
• x = [] റിട്ടേൺ തരം വ്യാഖ്യാനമില്ലാതെ ഒരു ഫംഗ്‌ഷനിൽ നിന്ന് മടങ്ങി - ഊഹിക്കുന്നതിനുപകരം പൈറൈറ്റ് ഒരു പിശക് റിപ്പോർട്ട് ചെയ്യുന്നു

ഈ ദ്വിദിശ അനുമാനം (തുടർന്നുള്ള ഉപയോഗവും കോൾ സൈറ്റുകളിൽ നിന്ന് പ്രതീക്ഷിക്കുന്ന തരങ്ങളും ഉപയോഗിച്ച്) ശൂന്യമായ കണ്ടെയ്‌നറുകൾക്കുള്ള mypy എന്നതിനേക്കാൾ പൈറൈറ്റ് കൂടുതൽ കൃത്യതയുള്ളതാക്കുന്നു. പല ഓപ്പൺ സോഴ്‌സ് മൈഗ്രേഷൻ റിപ്പോർട്ടുകളിൽ നിന്നുള്ള വിശകലനമനുസരിച്ച്, mypy-യുടെ സ്‌ട്രിക്‌റ്റ് മോഡുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ, ഒരു സാധാരണ അനോട്ട് ചെയ്യാത്ത കോഡ്‌ബേസിൽ, പൈററ്റിൻ്റെ സ്‌ട്രിക്‌റ്റ് മോഡ് ഏകദേശം 30-40% കൂടുതൽ പ്രശ്‌നങ്ങൾ ഫ്ലാഗ് ചെയ്യുന്നു. സങ്കീർണ്ണമായ ബാക്കെൻഡ് സിസ്റ്റങ്ങൾ നിർമ്മിക്കുന്ന ടീമുകൾക്ക് - പറയുക, CRM, പേറോൾ, അനലിറ്റിക്സ് എന്നിവയിൽ വ്യാപിച്ചുകിടക്കുന്ന 207 പരസ്പര ബന്ധിത മൊഡ്യൂളുകൾ കൈകാര്യം ചെയ്യുന്ന ഒരു പ്ലാറ്റ്ഫോം - പൈറൈറ്റിൻ്റെ കർശനത, മൃദുവായ അനുമാനം നഷ്‌ടപ്പെടുത്തുന്ന സൂക്ഷ്മമായ ഇൻ്റർഫേസ് പൊരുത്തക്കേടുകൾ പിടിക്കുന്നു.

Pytype and Pyre: The Les Travelled Roads

Google-ൻ്റെ പൈടൈപ്പ് ഒരുപക്ഷേ ഏറ്റവും പ്രായോഗികമായ സമീപനമാണ് സ്വീകരിക്കുന്നത്. വ്യാഖ്യാനങ്ങൾ ആവശ്യപ്പെടുകയോ ഏതെങ്കിലും എന്നതിലേക്ക് മടങ്ങുകയോ ചെയ്യുന്നതിനുപകരം, ഫംഗ്‌ഷൻ അതിരുകളിലുടനീളം ഒരു കണ്ടെയ്‌നർ എങ്ങനെ ഉപയോഗിക്കപ്പെടുന്നുവെന്ന് ട്രാക്കുചെയ്യുന്നതിന് pytype മുഴുവൻ-പ്രോഗ്രാം വിശകലനം ഉപയോഗിക്കുന്നു. നിങ്ങൾ ഒരു ഫംഗ്‌ഷനിൽ ഒരു ശൂന്യമായ ലിസ്‌റ്റ് സൃഷ്‌ടിക്കുകയും പൂർണ്ണസംഖ്യകൾ കൂട്ടിച്ചേർക്കുന്ന മറ്റൊന്നിലേക്ക് കൈമാറുകയും ചെയ്‌താൽ, വ്യാഖ്യാനങ്ങളൊന്നും കൂടാതെ തന്നെ pytype-ന് പലപ്പോഴും list[int] അനുമാനിക്കാം. ഈ ക്രോസ്-ഫംഗ്ഷൻ അനുമാനം കമ്പ്യൂട്ടേഷണൽ ചെലവേറിയതാണ് - വലിയ കോഡ്ബേസുകളിലെ മൈപി അല്ലെങ്കിൽ പൈറൈറ്റിനേക്കാൾ പൈടൈപ്പ് വളരെ മന്ദഗതിയിലാണ് - എന്നാൽ ഇത് വ്യാഖ്യാനിക്കാത്ത കോഡിൽ കുറച്ച് തെറ്റായ പോസിറ്റീവുകൾ സൃഷ്ടിക്കുന്നു.

ശൂന്യമായ കണ്ടെയ്‌നറുകൾക്കായി "ഭാഗിക തരങ്ങൾ" എന്ന ആശയവും Pytype അവതരിപ്പിക്കുന്നു. പുതുതായി സൃഷ്‌ടിച്ച [] ഒരു ഭാഗിക തരം ലഭിക്കുന്നു, അത് ചെക്കർ കൂടുതൽ ഉപയോഗം നേരിടുന്നതിനാൽ ക്രമേണ പരിഷ്‌ക്കരിക്കുന്നു. ഇത് ആശയപരമായി ഗംഭീരമാണ്, എന്നാൽ ഭാഗിക തരം പൂർണ്ണമായി പരിഹരിക്കാൻ കഴിയാതെ വരുമ്പോൾ ആശയക്കുഴപ്പമുണ്ടാക്കുന്ന പിശക് സന്ദേശങ്ങൾ സൃഷ്ടിക്കാൻ കഴിയും.

അതേസമയം, മെറ്റയുടെ പൈർ മൈപിയുടെ പെരുമാറ്റത്തോട് കൂടുതൽ അടുക്കുന്നു, എന്നാൽ കർശനമായ സ്ഥിരസ്ഥിതികളോടെ. പൈർ x = [] ലിസ്റ്റ്[അജ്ഞാതം] ആയി കണക്കാക്കുന്നു കൂടാതെ മിക്ക സന്ദർഭങ്ങളിലും വ്യാഖ്യാനം ആവശ്യമാണ്. വെബ് ചട്ടക്കൂടുകളിലെ ഒരു സാധാരണ പാറ്റേണായ ക്വാർഗുകളായി ഉപയോഗിക്കുന്ന ശൂന്യമായ നിഘണ്ടു അക്ഷരങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിലാണ് പൈർ സ്വയം വ്യതിരിക്തമാകുന്നത്. കീവേഡ് ആർഗ്യുമെൻ്റ് സന്ദർഭങ്ങളിൽ നിന്ന് നിഘണ്ടു തരങ്ങൾ അനുമാനിക്കാൻ പൈറിന് പ്രത്യേക-കേസ് ലോജിക് ഉണ്ട്, ഫ്രെയിംവർക്ക്-ഹെവി കോഡ്ബേസുകളിൽ വ്യാഖ്യാന ഭാരം കുറയ്ക്കുന്നു. മിക്ക ആധുനിക വെബ് ആപ്ലിക്കേഷനുകളിലും കോൺഫിഗറേഷനും അഭ്യർത്ഥന കൈകാര്യം ചെയ്യുന്നതിനുമായി നിഘണ്ടു അൺപാക്കിംഗിൻ്റെ കനത്ത ഉപയോഗം ഉൾപ്പെടുന്നു, ഈ പ്രായോഗികത ലാഭവിഹിതം നൽകുന്നു.

യഥാർത്ഥ ലോക ആഘാതം: അനുമാനം വ്യതിചലനം കടിക്കുമ്പോൾ

പ്രൊഡക്ഷൻ കോഡ്ബേസിൽ നിങ്ങൾ അനുഭവിക്കുന്നതുവരെ തരം ചെക്കറുകൾ തമ്മിലുള്ള വ്യത്യാസങ്ങൾ അക്കാദമിക് ആയി തോന്നിയേക്കാം. ബിസിനസ്സ് ആപ്ലിക്കേഷനുകളിൽ പൊതുവായ ഒരു പാറ്റേൺ പരിഗണിക്കുക: സോപാധികമായി ജനസംഖ്യയുള്ള ഒരു ഡാറ്റ ഘടന ആരംഭിക്കുന്നു.

ഏറ്റവും അപകടകരമായ ശൂന്യമായ കണ്ടെയ്‌നറുകൾ ഒരു തരം ചെക്കർ ഫ്ലാഗ് അല്ല - അവ ഒരു അനുമാനിച്ച ഏത് തരത്തിനൊപ്പം നിശബ്ദമായി കടന്നുപോകുന്നവയാണ്, ഒരു ഡൗൺസ്‌ട്രീം ഫംഗ്‌ഷൻ റൺടൈമിൽ ഒരു ഡൗൺസ്‌ട്രീം ഫംഗ്‌ഷൻ ക്രാഷുചെയ്യുന്നത് വരെ മുന്നറിയിപ്പില്ലാതെ ശേഖരിക്കാൻ അനുവദിക്കുന്നു, അത് അതിൻ്റെ ഉത്ഭവത്തിലേക്ക് തിരികെ കണ്ടെത്താൻ അസാധ്യമാണ്.

ഒരു മൂർത്തമായ ഉദാഹരണം: ഒരു ഫിൻടെക് സ്റ്റാർട്ടപ്പിലെ ഒരു ടീം ഒരു പ്രൊഡക്ഷൻ പ്രശ്‌നം ഡീബഗ്ഗ് ചെയ്യാൻ മൂന്ന് ദിവസം ചെലവഴിച്ചതായി റിപ്പോർട്ട് ചെയ്തു അവിടെ ഒരു പേയ്‌മെൻ്റ് പ്രോസസ്സിംഗ് ഫംഗ്‌ഷനിൽ ആരംഭിച്ച ഒരു ശൂന്യമായ ലിസ്‌റ്റ് mypy list[Any] ആയി അനുമാനിക്കപ്പെടുന്നു. ലിസ്‌റ്റിൽ കറൻസി തുകകൾക്കായുള്ള ദശാംശം ഒബ്‌ജക്‌റ്റുകൾ അടങ്ങിയിരിക്കണം, എന്നാൽ പകരം ഒരു കോഡ് പാത്ത് ഫ്ലോട്ട് മൂല്യങ്ങൾ കൂട്ടിച്ചേർക്കുന്നു. മൈപിയുടെ മൃദുലമായ അനുമാനം അതിനെ നിശബ്ദമായി അനുവദിച്ചു. ഫ്ലോട്ട് ഗണിതത്തിലെ റൗണ്ടിംഗ് പിശകുകൾ 12,000 ഇൻവോയ്സുകളുടെ ഒരു ബാച്ചിൽ $0.01 പൊരുത്തക്കേടുണ്ടാക്കിയപ്പോൾ മാത്രമാണ് ബഗ് പ്രത്യക്ഷപ്പെട്ടത്. അവർ കർശനമായ മോഡിൽ പൈറൈറ്റ് ഉപയോഗിക്കുകയോ ശൂന്യമായ ലിസ്റ്റ് ലിസ്റ്റ്[ദശാംശം] എന്ന് വ്യാഖ്യാനിക്കുകയോ ചെയ്തിരുന്നെങ്കിൽ, വികസന സമയത്ത് ബഗ് പിടിക്കപ്പെടുമായിരുന്നു.

138,000+ ഉപയോക്തൃ അക്കൗണ്ടുകളിലുടനീളം പ്ലാറ്റ്‌ഫോം ഇൻവോയ്‌സിംഗ്, പേറോൾ കണക്കുകൂട്ടലുകൾ, സാമ്പത്തിക വിശകലനങ്ങൾ എന്നിവ പ്രോസസ്സ് ചെയ്യുന്ന Mewayz-ൽ, ഇത്തരത്തിലുള്ള തരം-സുരക്ഷാ വിടവ് സൈദ്ധാന്തികമല്ല - ഇത് ശരിയായ പേറോൾ റണ്ണുകളും ചെലവേറിയ വീണ്ടും കണക്കുകൂട്ടലുകളും തമ്മിലുള്ള വ്യത്യാസമാണ്. കണ്ടെയ്‌നർ ഇനീഷ്യലൈസേഷനെ ചുറ്റിപ്പറ്റിയുള്ള കർശനമായ ടൈപ്പിംഗ് അച്ചടക്കം, ആവേശകരമായ ഉൽപ്പാദന സംഭവങ്ങളെ തടയുന്ന "ബോറടിപ്പിക്കുന്ന" എഞ്ചിനീയറിംഗ് രീതികളിൽ ഒന്നാണ്.

പ്രതിരോധ കണ്ടെയ്നർ ആരംഭിക്കുന്നതിനുള്ള മികച്ച സമ്പ്രദായങ്ങൾ

നിങ്ങളുടെ ടീം ഏത് തരത്തിലുള്ള ചെക്കറാണ് ഉപയോഗിക്കുന്നത് എന്നത് പരിഗണിക്കാതെ തന്നെ, ശൂന്യമായ കണ്ടെയ്‌നറിൻ്റെ അവ്യക്തത പൂർണ്ണമായും ഇല്ലാതാക്കാൻ കൃത്യമായ തന്ത്രങ്ങളുണ്ട്. ശൂന്യമായ കണ്ടെയ്‌നറുകൾക്കായി ഒരിക്കലും അനുമാനത്തെ ആശ്രയിക്കരുത് എന്നതാണ് ലക്ഷ്യം - തരം സ്പഷ്ടമാക്കുക, അങ്ങനെ നിങ്ങളുടെ കോഡ് എല്ലാ ചെക്കറുകളിലും പോർട്ടബിൾ ആക്കുകയും പതിപ്പുകൾക്കിടയിലുള്ള അനുമാന സ്വഭാവ മാറ്റങ്ങളിൽ നിന്ന് പ്രതിരോധിക്കുകയും ചെയ്യുന്നു.

1. എല്ലായ്‌പ്പോഴും ശൂന്യമായ കണ്ടെയ്‌നർ വേരിയബിളുകൾ വ്യാഖ്യാനിക്കുക. ഫലങ്ങൾ = [] എന്നതിന് പകരം ഫലങ്ങൾ: list[int] = [] എഴുതുക. ലാഭിക്കുന്ന ഡീബഗ്ഗിംഗ് സമയവുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ മൈനർ വെർബോസിറ്റി ചെലവ് തുച്ഛമാണ്. ഈ ഒരൊറ്റ പ്രാക്ടീസ് ഏകദേശം 80% ശൂന്യമായ കണ്ടെയ്നർ അനുമാന പ്രശ്നങ്ങളെ ഇല്ലാതാക്കുന്നു.
2. സങ്കീർണ്ണമായ കണ്ടെയ്‌നറുകൾക്കായി ഫാക്ടറി ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കുക. കാഷെ = {} എന്നതിനുപകരം, def make_cache() -> dict[str, list[UserRecord]] പോലെയുള്ള ഒരു ഫംഗ്‌ഷൻ എഴുതുക: {} മടങ്ങുക. റിട്ടേൺ ടൈപ്പ് വ്യാഖ്യാനം ഉദ്ദേശിച്ച തരത്തെ അവ്യക്തവും സ്വയം രേഖപ്പെടുത്തുന്നതുമാക്കുന്നു.
3. നിസ്സാരമല്ലാത്ത തരങ്ങൾക്ക് ലിറ്ററലുകളേക്കാൾ ടൈപ്പ് ചെയ്‌ത കൺസ്‌ട്രക്‌ടറുകൾ മുൻഗണന നൽകുക. സെറ്റ് കോംപ്രഹെൻഷൻ അനുമാനത്തെ ആശ്രയിക്കുന്നതിനുപകരം ഇനങ്ങൾ: set[int] = set() എഴുതുക. defaultdict, Counter എന്നിവയ്‌ക്കായി, എല്ലായ്‌പ്പോഴും തരം പാരാമീറ്റർ നൽകുക: counts: Counter[str] = Counter().
4. പുതിയ കോഡിനായി നിങ്ങളുടെ ടൈപ്പ് ചെക്കറിൻ്റെ കർശനമായ മോഡ് കോൺഫിഗർ ചെയ്യുക. mypy, pyright എന്നിവ ഓരോ ഫയലിനും ഓരോ ഡയറക്‌ടറി കോൺഫിഗറേഷനും പിന്തുണ നൽകുന്നു. ലെഗസി കോഡ് ക്രമേണ മൈഗ്രേറ്റ് ചെയ്യുമ്പോൾ പുതിയ മൊഡ്യൂളുകളിൽ കർശനമായ പരിശോധന പ്രവർത്തനക്ഷമമാക്കുക. ഇത് പുതിയ അവ്യക്തമായി ടൈപ്പ് ചെയ്ത കണ്ടെയ്‌നറുകൾ ശേഖരിക്കുന്നത് തടയുന്നു.
5. നിങ്ങളുടെ CI പൈപ്പ് ലൈനിലേക്ക് ടൈപ്പ് ചെക്കർ താരതമ്യം ചേർക്കുക. നിങ്ങളുടെ കോഡ് ബേസിൽ mypy, pyright എന്നിവ പ്രവർത്തിപ്പിക്കുന്നത് നേരത്തെ തന്നെ അനുമാന വ്യതിചലനം കണ്ടെത്തുന്നു. ഒരു പാറ്റേൺ ഒരു ചെക്കറിനെ മറികടന്ന് മറ്റൊന്ന് പരാജയപ്പെടുകയാണെങ്കിൽ, അത് തരം വ്യക്തമല്ല എന്നതിൻ്റെ സൂചനയാണ്.

വലിയ ചിത്രം: ഒരു ടീം പരിശീലനമായി ടൈപ്പ് ചെക്കിംഗ്

ശൂന്യമായ കണ്ടെയ്‌നർ അനുമാനം ആത്യന്തികമായി പൈത്തണിൻ്റെ തരം സിസ്റ്റത്തിലെ ഒരു വലിയ വെല്ലുവിളിയുടെ മൈക്രോകോസമാണ്: സൗകര്യവും സുരക്ഷയും തമ്മിലുള്ള പിരിമുറുക്കം. "ഞങ്ങൾ എല്ലാവരും മുതിർന്നവരാണ്" എന്ന പൈത്തണിൻ്റെ തത്ത്വചിന്ത പ്രോട്ടോടൈപ്പിംഗിനും സ്ക്രിപ്റ്റുകൾക്കും മനോഹരമായി പ്രവർത്തിക്കുന്നു, എന്നാൽ ആയിരക്കണക്കിന് ഉപയോക്താക്കൾക്ക് സേവനം നൽകുന്ന പ്രൊഡക്ഷൻ സിസ്റ്റങ്ങൾക്ക് ശക്തമായ ഗ്യാരണ്ടി ആവശ്യമാണ്. [] തരം പോലെ അടിസ്ഥാനപരമായ കാര്യങ്ങളിൽ നാല് പ്രധാന തരം ചെക്കറുകൾ വിയോജിക്കുന്നു എന്ന വസ്തുത, പൈത്തൺ ടൈപ്പിംഗ് ഇക്കോസിസ്റ്റം ഇപ്പോഴും പക്വത പ്രാപിച്ചുകൊണ്ടിരിക്കുകയാണെന്ന് അടിവരയിടുന്നു.

സങ്കീർണ്ണമായ പ്ലാറ്റ്‌ഫോമുകൾ നിർമ്മിക്കുന്ന എഞ്ചിനീയറിംഗ് ടീമുകൾക്ക് - നിങ്ങൾ ഒരുപിടി മൈക്രോസർവീസുകളോ അല്ലെങ്കിൽ Mewayz ൻ്റെ ബിസിനസ്സ് OS പോലുള്ള നൂറുകണക്കിന് പരസ്പര ബന്ധിത മൊഡ്യൂളുകളുള്ള ഒരു സംയോജിത സംവിധാനമോ കൈകാര്യം ചെയ്യുകയാണെങ്കിലും - പ്രായോഗിക ഉപദേശം നേരായതാണ്: ശൂന്യമായ കണ്ടെയ്‌നറുകൾക്കായി അനുമാനത്തെ ആശ്രയിക്കരുത്, ഒരു ടൈപ്പ് ചെക്കർ തിരഞ്ഞെടുത്ത് അത് കർശനമായി ക്രമീകരിക്കുക. [] എന്നതിനുപകരം ലിസ്റ്റ്[ഇൻവോയ്സ്] എഴുതാൻ ചെലവഴിച്ച അഞ്ച് മിനിറ്റ്, നിങ്ങളുടെ കോഡ്ബേസ് സ്കെയിൽ ചെയ്യുമ്പോൾ മണിക്കൂറുകളോളം ഡീബഗ്ഗിംഗ് ലാഭിക്കും.

പിഇപി 696 (ഡിഫോൾട്ട് ടൈപ്പ് പാരാമീറ്ററുകൾ), പിഇപി 695 (തരം പാരാമീറ്റർ സിൻ്റാക്സ്) എന്നിവ പുതിയ പൈത്തൺ പതിപ്പുകളിൽ ഇറങ്ങുന്നത് തുടരുന്നതിനാൽ, വ്യക്തമായ ടൈപ്പിംഗിൻ്റെ എർഗണോമിക്‌സ് മെച്ചപ്പെടുന്നു. "വ്യാഖ്യാനം ചെയ്യാത്ത" പൈത്തണിൻ്റെ വിടവ് കുറയും. എന്നാൽ ആ ദിവസം വരെ, പൈത്തൺ ഡെവലപ്പറുടെ ടൂൾകിറ്റിലെ ഏറ്റവും ഉയർന്ന ROI സമ്പ്രദായങ്ങളിൽ ഒന്നായി വ്യക്തമായ കണ്ടെയ്‌നർ തരങ്ങൾ നിലനിൽക്കുന്നു - എല്ലാ മൊഡ്യൂളുകളിലും എല്ലാ സ്‌പ്രിൻ്റുകളിലും എല്ലാ പ്രൊഡക്ഷൻ വിന്യാസത്തിലും കൂട്ടുപലിശ നൽകുന്ന ഒരു ചെറിയ അച്ചടക്കം.

പതിവ് ചോദിക്കുന്ന ചോദ്യങ്ങൾ

എന്തുകൊണ്ട് ടൈപ്പ് ചെക്കറുകൾക്ക് ഒരു ശൂന്യമായ ലിസ്‌റ്റിൻ്റെ തരം അംഗീകരിക്കാൻ കഴിയില്ല?

നിങ്ങൾ `x = []` എന്ന് എഴുതുമ്പോൾ, ടൈപ്പ് ചെക്കർ വ്യക്തമായ സൂചനകളില്ലാതെ ഒരു തരം അനുമാനിക്കണം. വ്യത്യസ്‌ത ചെക്കർമാർ വ്യത്യസ്‌ത സ്‌ട്രാറ്റജികൾ ഉപയോഗിക്കുന്നു: ചിലർ `ലിസ്റ്റ്[ഏതെങ്കിലും]` (എന്തിൻ്റെയും ഒരു ലിസ്റ്റ്) അനുമാനിക്കുന്നു, മറ്റുള്ളവർ `ലിസ്റ്റ്[ഒന്നുമില്ല]` പോലെയുള്ള കൂടുതൽ നിർദ്ദിഷ്ടവും എന്നാൽ തെറ്റായതുമായ തരം അനുമാനിച്ചേക്കാം. ഒരു സാർവത്രിക നിലവാരമില്ലാത്തതാണ് അവർ വിയോജിക്കാൻ കാരണം. ഒന്നിലധികം ചെക്കറുകൾ ഉപയോഗിക്കുന്ന പ്രോജക്റ്റുകൾക്ക്, ഈ പൊരുത്തക്കേട് ഒരു വലിയ തലവേദനയായിരിക്കാം, ഒരു ടൂളിലെ വിശകലനത്തെ തകർക്കുന്നു.

ശൂന്യമായ കണ്ടെയ്‌നർ പിശകുകൾ പരിഹരിക്കാനുള്ള ഏറ്റവും ലളിതമായ മാർഗം എന്താണ്?

സ്പഷ്‌ടമായ തരത്തിലുള്ള വ്യാഖ്യാനം നൽകുക എന്നതാണ് ഏറ്റവും ലളിതമായ പരിഹാരം. `my_list = []` എന്നതിന് പകരം, ഉദ്ദേശിച്ച തരം വ്യക്തമായി പ്രഖ്യാപിക്കാൻ `my_list: list[str] = []` എന്ന് എഴുതുക. ഇത് ടൈപ്പ് ചെക്കറിനുള്ള എല്ലാ അവ്യക്തതയും നീക്കം ചെയ്യുന്നു, mypy, Pyright, Pyre എന്നിങ്ങനെയുള്ള വിവിധ ടൂളുകളിലുടനീളം സ്ഥിരമായ പെരുമാറ്റം ഉറപ്പാക്കുന്നു. അനുമാന പിശകുകൾ തടയാൻ എല്ലാ ശൂന്യമായ കണ്ടെയ്‌നർ ഇനിഷ്യലൈസേഷനുകൾക്കും ഈ രീതി ശുപാർശ ചെയ്യുന്നു.

ക്ലാസ് നിർവചനങ്ങൾക്കുള്ളിൽ ശൂന്യമായ കണ്ടെയ്‌നറുകൾ ഞാൻ എങ്ങനെ കൈകാര്യം ചെയ്യും?

ക്ലാസുകൾക്കുള്ളിലെ വ്യാഖ്യാനങ്ങൾക്ക് പ്രത്യേക കൈകാര്യം ചെയ്യൽ ആവശ്യമായതിനാൽ ഇതൊരു സാധാരണ പ്രശ്നമാണ്. ലിസ്‌റ്റ് ഒരു ക്ലാസ് ആട്രിബ്യൂട്ട് ആകാനാണ് ഉദ്ദേശിക്കുന്നതെങ്കിൽ നിങ്ങൾ `__ഭാവി__ ഇറക്കുമതി വ്യാഖ്യാനങ്ങളിൽ നിന്ന്' ഇമ്പോർട്ടോ ഒരു `ClassVar` വ്യാഖ്യാനമോ ഉപയോഗിക്കണം. ഉദാഹരണത്തിന്, `class MyClass: my_list: ClassVar[list[str]] = []`. ഇത് കൂടാതെ, ടൈപ്പ് ചെക്കറിന് തരം ശരിയായി അനുമാനിക്കാൻ പാടുപെടാം, ഇത് പിശകുകളിലേക്ക് നയിക്കുന്നു.

വലിയ പ്രോജക്റ്റുകളിൽ ഈ ടൈപ്പിംഗ് പ്രശ്നങ്ങൾ കൈകാര്യം ചെയ്യാൻ സഹായിക്കുന്ന ടൂളുകൾ ഉണ്ടോ?

അതെ, പൈറൈറ്റ് (വിഎസ് കോഡിലെ പൈലൻസിന് അധികാരം നൽകുന്ന) പോലുള്ള അഡ്വാൻസ്ഡ് ടൈപ്പ് ചെക്കറുകൾ സങ്കീർണ്ണമായ അനുമാനം കൈകാര്യം ചെയ്യുന്നതിൽ വളരെ മികച്ചതാണ്. വലിയ കോഡ്ബേസുകൾക്കായി, Mewayz പോലുള്ള പ്ലാറ്റ്‌ഫോമുകൾക്ക് (പ്രതിമാസം $19-ന് 207 വിശകലന മൊഡ്യൂളുകൾ വാഗ്ദാനം ചെയ്യുന്നു) ആഴത്തിലുള്ളതും കൂടുതൽ സ്ഥിരതയുള്ളതുമായ തരം പരിശോധന നൽകാനും ലേഖനത്തിൽ ചർച്ച ചെയ്തിട്ടുള്ള പൊരുത്തക്കേടുകൾ ലഘൂകരിക്കാനും നിങ്ങളുടെ ടീമിലുടനീളം വ്യാഖ്യാന രീതികൾ നടപ്പിലാക്കാൻ സഹായിക്കാനും കഴിയും.