పైథాన్ కోడ్ రకం నియంత్రణతో డ్రాప్‌బాక్స్ ఎలా వ్యవహరిస్తుందనే దాని గురించి మెటీరియల్ యొక్క అనువాదం యొక్క మొదటి భాగాన్ని ఈ రోజు మేము మీ దృష్టికి తీసుకువస్తాము.
డ్రాప్‌బాక్స్ పైథాన్‌లో చాలా వ్రాస్తుంది. ఇది మేము చాలా విస్తృతంగా ఉపయోగించే భాష - బ్యాకెండ్ సేవలు మరియు డెస్క్‌టాప్ క్లయింట్ అప్లికేషన్‌ల కోసం. మేము గో, టైప్‌స్క్రిప్ట్ మరియు రస్ట్‌లను కూడా ఎక్కువగా ఉపయోగిస్తాము, అయితే పైథాన్ మా ప్రధాన భాష. మా స్థాయిని పరిశీలిస్తే, మరియు మేము మిలియన్ల కొద్దీ పైథాన్ కోడ్ లైన్ల గురించి మాట్లాడుతున్నాము, అటువంటి కోడ్ యొక్క డైనమిక్ టైపింగ్ అనవసరంగా దాని అవగాహనను క్లిష్టతరం చేస్తుంది మరియు కార్మిక ఉత్పాదకతను తీవ్రంగా ప్రభావితం చేయడం ప్రారంభించింది. ఈ సమస్యను తగ్గించడానికి, మేము క్రమంగా మా కోడ్‌ని mypyని ఉపయోగించి స్టాటిక్ టైప్ చెకింగ్‌కి మార్చడం ప్రారంభించాము. ఇది బహుశా పైథాన్ కోసం అత్యంత ప్రజాదరణ పొందిన స్టాండ్-అలోన్ టైప్ చెకింగ్ సిస్టమ్. Mypy ఒక ఓపెన్ సోర్స్ ప్రాజెక్ట్, దాని ప్రధాన డెవలపర్లు Dropboxలో పని చేస్తారు.
ఈ స్థాయిలో పైథాన్ కోడ్‌లో స్టాటిక్ టైప్ చెకింగ్‌ను అమలు చేసిన మొదటి కంపెనీలలో డ్రాప్‌బాక్స్ ఒకటి. ఈ రోజుల్లో వేలాది ప్రాజెక్ట్‌లలో Mypy ఉపయోగించబడుతుంది. ఈ సాధనం, వారు చెప్పినట్లుగా, లెక్కలేనన్ని సార్లు "యుద్ధంలో పరీక్షించబడింది". ఇప్పుడున్న స్థితికి రావాలంటే చాలా దూరం రావాల్సి వచ్చింది. ఈ మార్గంలో అనేక విఫల ప్రయత్నాలు మరియు విఫలమైన ప్రయోగాలు ఉన్నాయి. ఈ భాగం పైథాన్‌లో స్టాటిక్ టైప్ చెకింగ్ చరిత్రను వివరిస్తుంది, నా అకడమిక్ రీసెర్చ్ ప్రాజెక్ట్‌లో భాగంగా దాని రాతి ప్రారంభం నుండి నేటి వరకు, టైప్ చెక్‌లు మరియు టైప్ సూచనలు లెక్కలేనన్ని పైథాన్ డెవలపర్‌లలో సర్వసాధారణంగా మారాయి. ఈ మెకానిజమ్‌లకు ఇప్పుడు IDEలు మరియు కోడ్ ఎనలైజర్‌ల వంటి అనేక రకాల సాధనాలు మద్దతునిస్తున్నాయి.
→
టైప్ చెకింగ్ ఎందుకు అవసరం?
మీరు ఎప్పుడైనా డైనమిక్‌గా టైప్ చేసిన పైథాన్‌ని ఉపయోగించినట్లయితే, ఈ మధ్యకాలంలో స్టాటిక్ టైపింగ్ మరియు మైపీ గురించి ఎందుకు చాలా రచ్చ జరుగుతోందో తెలియక మీరు కొంచెం గందరగోళానికి గురవుతారు. లేదా మీరు పైథాన్‌ని దాని డైనమిక్ టైపింగ్ కారణంగా ఖచ్చితంగా ఇష్టపడవచ్చు మరియు ఏమి జరుగుతుందో అది మిమ్మల్ని కలవరపెడుతుంది. స్టాటిక్ టైపింగ్ విలువకు కీలకం నిర్ణయాల స్థాయి: మీ ప్రాజెక్ట్ ఎంత పెద్దదైతే, మీరు స్టాటిక్ టైపింగ్ వైపు ఎక్కువ మొగ్గు చూపుతారు మరియు అంతిమంగా, మీకు నిజంగా ఇది అవసరం.
ఒక ప్రాజెక్ట్ పరిమాణంలో పదివేల పంక్తులకు చేరుకుందని అనుకుందాం మరియు అనేక మంది ప్రోగ్రామర్లు దానిపై పని చేస్తున్నారని తేలింది. ఇలాంటి ప్రాజెక్ట్‌ను పరిగణనలోకి తీసుకున్నప్పుడు, మా అనుభవం ఆధారంగా, డెవలపర్ ఉత్పాదకతను నిర్వహించడానికి దాని కోడ్‌ను అర్థం చేసుకోవడం కీలకమని మేము చెప్పగలం. రకం ఉల్లేఖనాలు లేకుండా, గుర్తించడం కష్టంగా ఉంటుంది, ఉదాహరణకు, ఒక ఫంక్షన్‌కు ఏ ఆర్గ్యుమెంట్‌లు పంపాలి లేదా నిర్దిష్ట ఫంక్షన్ ఏ రకమైన విలువలను తిరిగి ఇవ్వగలదో. టైప్ ఉల్లేఖనాలను ఉపయోగించకుండా సమాధానం ఇవ్వడం చాలా కష్టంగా ఉండే సాధారణ ప్రశ్నలు ఇక్కడ ఉన్నాయి:
- ఈ ఫంక్షన్ తిరిగి రావచ్చు
None? - ఈ వాదన ఎలా ఉండాలి?
items? - లక్షణం రకం ఏమిటి
id:intఔనా,str, లేదా ఏదైనా అనుకూల రకం ఉండవచ్చు? - ఈ వాదన జాబితాగా ఉండాలా? దానిలోకి టుపుల్ పాస్ చేయడం సాధ్యమేనా?
మీరు క్రింది టైప్-ఉల్లేఖన కోడ్ స్నిప్పెట్‌ని చూసి, ఇలాంటి ప్రశ్నలకు సమాధానమివ్వడానికి ప్రయత్నిస్తే, ఇది చాలా సులభమైన పని అని తేలింది:
class Resource:
id: bytes
...
def read_metadata(self,
items: Sequence[str]) -> Dict[str, MetadataItem]:
...read_metadataతిరిగి రాదుNoneఎందుకంటే తిరిగి వచ్చే రకం కాదుOptional[…].- వాదన
itemsపంక్తుల క్రమం. ఇది ఏ క్రమంలోనూ పునరావృతం చేయబడదు. - గుణం
idబైట్‌ల స్ట్రింగ్.
ఆదర్శవంతమైన ప్రపంచంలో, అంతర్నిర్మిత డాక్యుమెంటేషన్ (డాక్‌స్ట్రింగ్)లో అటువంటి సూక్ష్మబేధాలన్నీ వివరించబడతాయని ఒకరు ఆశించవచ్చు. కానీ మీరు పని చేయాల్సిన కోడ్‌లో ఇటువంటి డాక్యుమెంటేషన్ తరచుగా గమనించబడదని అనుభవం చాలా ఉదాహరణలను అందిస్తుంది. అటువంటి డాక్యుమెంటేషన్ కోడ్‌లో ఉన్నప్పటికీ, మీరు దాని సంపూర్ణ ఖచ్చితత్వాన్ని లెక్కించలేరు. ఈ డాక్యుమెంటేషన్ అస్పష్టంగా, అస్పష్టంగా ఉండవచ్చు మరియు అపార్థానికి దారితీయవచ్చు. పెద్ద జట్లు లేదా పెద్ద ప్రాజెక్ట్‌లలో, ఈ సమస్య చాలా తీవ్రంగా ఉంటుంది.
పైథాన్ ప్రారంభ లేదా మధ్య-దశ ప్రాజెక్ట్‌లలో రాణిస్తున్నప్పటికీ, ఏదో ఒక సమయంలో విజయవంతమైన ప్రాజెక్ట్‌లు మరియు పైథాన్‌ని ఉపయోగించే కంపెనీలు ఒక ముఖ్యమైన ప్రశ్నను ఎదుర్కోవచ్చు: "మేము ప్రతిదానిని స్టాటిక్‌గా టైప్ చేసిన భాషలో తిరిగి వ్రాయాలా?"
mypy వంటి టైప్ చెకింగ్ సిస్టమ్‌లు డెవలపర్‌కు రకాలను వివరించడానికి అధికారిక భాషను అందించడం ద్వారా పై సమస్యను పరిష్కరిస్తాయి మరియు ప్రోగ్రామ్ అమలుకు సరిపోయే రకం డిక్లరేషన్‌లను తనిఖీ చేయడం ద్వారా (మరియు, ఐచ్ఛికంగా, వాటి ఉనికిని తనిఖీ చేయడం). సాధారణంగా, ఈ వ్యవస్థలు జాగ్రత్తగా ధృవీకరించబడిన డాక్యుమెంటేషన్ వంటి వాటిని మాకు అందజేస్తాయని మేము చెప్పగలం.
అటువంటి వ్యవస్థల ఉపయోగం ఇతర ప్రయోజనాలను కలిగి ఉంది మరియు అవి పూర్తిగా అల్పమైనవి కావు:
- టైప్ చెకింగ్ సిస్టమ్ కొన్ని చిన్న (మరియు అంత చిన్నది కాదు) లోపాలను గుర్తించగలదు. వారు విలువను ప్రాసెస్ చేయడం మర్చిపోయినప్పుడు ఒక సాధారణ ఉదాహరణ
Noneలేదా కొన్ని ఇతర ప్రత్యేక పరిస్థితి. - రీఫ్యాక్టరింగ్ కోడ్ చాలా సరళీకృతం చేయబడింది ఎందుకంటే టైప్ చెకర్ తరచుగా మీకు ఏ కోడ్‌ని మార్చాలో ఖచ్చితంగా చెబుతుంది. అదే సమయంలో, మేము కోడ్ యొక్క 100% పరీక్ష కవరేజీపై ఆధారపడవలసిన అవసరం లేదు, ఇది సాధారణంగా ఏ సందర్భంలోనైనా అసాధ్యం. తప్పు ఏమిటో గుర్తించడానికి మేము స్టాక్ ట్రేస్ నివేదికలను లోతుగా తీయవలసిన అవసరం లేదు.
- పెద్ద ప్రాజెక్ట్‌లలో కూడా, mypy తరచుగా సెకనులో కొంత భాగానికి పూర్తి రకం తనిఖీని చేయగలదు. మరియు రన్నింగ్ పరీక్షలు సాధారణంగా పదుల సెకన్లు లేదా నిమిషాలు కూడా పడుతుంది. టైప్ చెకింగ్ సిస్టమ్ ప్రోగ్రామర్‌కు తక్షణ అభిప్రాయాన్ని అందిస్తుంది మరియు అతని పనిని వేగంగా చేయడానికి అనుమతిస్తుంది. అతను ఇకపై వేగవంతమైన కోడ్ పరీక్ష ఫలితాలను పొందడానికి మాక్స్ మరియు ప్యాచ్‌లతో నిజమైన ఎంటిటీలను భర్తీ చేసే యూనిట్ పరీక్షలను పెళుసుగా మరియు నిర్వహించడం కష్టంగా వ్రాయవలసిన అవసరం లేదు.
IDEలు మరియు PyCharm లేదా Visual Studio Code వంటి ఎడిటర్‌లు డెవలపర్‌లకు ఆటోమేటిక్ కోడ్ పూర్తి చేయడం, ఎర్రర్ హైలైట్ చేయడం మరియు సాధారణంగా ఉపయోగించే భాషా నిర్మాణాలకు మద్దతుని అందించడానికి టైప్ ఉల్లేఖనాల శక్తిని ఉపయోగిస్తాయి. మరియు ఇవి టైపిఫికేషన్ అందించే కొన్ని ప్రయోజనాలే. కొంతమంది ప్రోగ్రామర్‌లకు, టైపింగ్‌కు అనుకూలంగా ఇవన్నీ ప్రధాన వాదన. ఇది అమలు చేసిన వెంటనే ప్రయోజనాలను తెస్తుంది. రకాలు కోసం ఈ వినియోగ సందర్భానికి mypy వంటి ప్రత్యేక రకం తనిఖీ వ్యవస్థ అవసరం లేదు, అయినప్పటికీ mypy రకం ఉల్లేఖనాలను కోడ్‌కు అనుగుణంగా ఉంచడంలో సహాయపడుతుందని గమనించాలి.
Mypy నేపథ్యం
నేను డ్రాప్‌బాక్స్‌లో చేరడానికి కొన్ని సంవత్సరాల ముందు UKలో, కేంబ్రిడ్జ్‌లో mypy కథ ప్రారంభమైంది. నా డాక్టోరల్ పరిశోధనలో భాగంగా, స్టాటిక్‌గా టైప్ చేసిన మరియు డైనమిక్ భాషలను ఏకీకృతం చేసే సమస్యపై నేను పనిచేశాను. నేను జెరెమీ సియెక్ మరియు వాలిద్ తాహ్ మరియు టైప్డ్ రాకెట్ ప్రాజెక్ట్ ద్వారా ఇంక్రిమెంటల్ టైపింగ్ గురించిన కథనం ద్వారా ప్రేరణ పొందాను. నేను వివిధ ప్రాజెక్ట్‌ల కోసం ఒకే ప్రోగ్రామింగ్ భాషను ఉపయోగించే మార్గాలను కనుగొనడానికి ప్రయత్నించాను - చిన్న స్క్రిప్ట్‌ల నుండి అనేక మిలియన్ల లైన్‌లతో కూడిన కోడ్‌బేస్‌ల వరకు. అదే సమయంలో, ఏ స్కేల్ ప్రాజెక్ట్‌లో అయినా నేను ఎక్కువ రాజీలు పడనవసరం లేదని నిర్ధారించుకోవాలనుకున్నాను. వీటన్నింటిలో ముఖ్యమైన భాగం ఏమిటంటే, టైప్ చేయని ప్రోటోటైప్ ప్రాజెక్ట్ నుండి సమగ్రంగా పరీక్షించబడిన, స్థిరంగా టైప్ చేయబడిన తుది ఉత్పత్తికి క్రమంగా మారడం. ఈ రోజుల్లో ఈ ఆలోచనలు చాలా వరకు మంజూరు చేయబడ్డాయి, కానీ 2010లో ఇది ఇప్పటికీ చురుకుగా పరిశోధన చేయబడే సమస్య.
టైప్ చెకింగ్‌లో నా ప్రారంభ పని పైథాన్‌ను లక్ష్యంగా చేసుకోలేదు. బదులుగా నేను ఒక చిన్న "ఇంట్లో" భాషను ఉపయోగించాను . మేము దేని గురించి మాట్లాడుతున్నామో మీకు ఆలోచన ఇవ్వడానికి ఇక్కడ ఒక ఉదాహరణ ఉంది (రకం ఉల్లేఖనాలు ఐచ్ఛికం):
def Fib(n as Int) as Int
if n <= 1
return n
else
return Fib(n - 1) + Fib(n - 2)
end
endమీ స్వంత డిజైన్ యొక్క సరళీకృత భాషను ఉపయోగించడం అనేది శాస్త్రీయ పరిశోధనలో ఉపయోగించే ఒక సాధారణ విధానం. ఇది అలా ఉంది, ఎందుకంటే ఇది త్వరగా ప్రయోగాలు చేయడం సాధ్యపడుతుంది మరియు పరిశోధనకు సంబంధించినది కాని వాటిని సులభంగా విస్మరించవచ్చు. నిజ-జీవిత ప్రోగ్రామింగ్ భాషలు సంక్లిష్టమైన అమలులతో పెద్ద-స్థాయి దృగ్విషయంగా ఉంటాయి, ఇది ప్రయోగాన్ని నెమ్మదిస్తుంది. ఏది ఏమైనప్పటికీ, సరళీకృత భాషపై ఆధారపడిన ఏవైనా ఫలితాలు కొద్దిగా అనుమానించబడతాయి, ఎందుకంటే ఈ ఫలితాలను పొందడంలో పరిశోధకుడు భాషల ఆచరణాత్మక ఉపయోగం కోసం ముఖ్యమైన పరిగణనలను త్యాగం చేసి ఉండవచ్చు.
అలోర్ కోసం నా టైప్ చెకర్ చాలా ఆశాజనకంగా కనిపించింది, కానీ నేను నిజంగా అలోర్‌లో వ్రాయని నిజమైన కోడ్‌తో ప్రయోగాలు చేయడం ద్వారా దీనిని పరీక్షించాలనుకుంటున్నాను. నా అదృష్టవశాత్తూ, అలోర్ భాష ఎక్కువగా పైథాన్ వంటి ఆలోచనలపైనే ఆధారపడి ఉంది. టైప్ చెకర్‌ని పునఃరూపకల్పన చేయడం చాలా సులభం, తద్వారా ఇది పైథాన్ సింటాక్స్ మరియు సెమాంటిక్స్‌తో పని చేస్తుంది. ఇది ఓపెన్ సోర్స్ పైథాన్ కోడ్‌లో టైప్ చెకింగ్ చేయడానికి ప్రయత్నించడానికి మమ్మల్ని అనుమతించింది. నేను అలోర్ కోడ్‌ని పైథాన్ కోడ్‌గా మార్చడానికి ట్రాన్స్‌పైలర్‌ను కూడా వ్రాసాను మరియు నా టైప్ చెకర్ కోడ్‌ని అనువదించడానికి దాన్ని ఉపయోగించాను. ఇప్పుడు నేను పైథాన్‌లో వ్రాసిన టైప్ చెకింగ్ సిస్టమ్‌ని కలిగి ఉన్నాను, అది పైథాన్ యొక్క ఉపసమితికి మద్దతు ఇస్తుంది, ఆ భాష యొక్క కొంత వైవిధ్యం! (అలోర్‌కు అర్ధమయ్యే కొన్ని నిర్మాణ నిర్ణయాలు పైథాన్‌కు సరిగ్గా సరిపోవు; ఇది ఇప్పటికీ mypy కోడ్‌బేస్‌లోని కొన్ని భాగాలలో స్పష్టంగా కనిపిస్తుంది.)
వాస్తవానికి, ఈ సమయంలో నా టైప్ సిస్టమ్ ద్వారా మద్దతు ఇవ్వబడిన భాషను పైథాన్ అని పిలవలేము: పైథాన్ 3 యొక్క టైప్ ఉల్లేఖన వాక్యనిర్మాణం యొక్క కొన్ని పరిమితుల కారణంగా ఇది పైథాన్ యొక్క రూపాంతరం.
ఇది జావా మరియు పైథాన్ మిశ్రమంలా కనిపించింది:
int fib(int n):
if n <= 1:
return n
else:
return fib(n - 1) + fib(n - 2)పైథాన్ యొక్క ఈ ఫ్లేవర్‌ను C లోకి లేదా బహుశా JVM బైట్‌కోడ్‌లోకి కంపైల్ చేయడం ద్వారా పనితీరును మెరుగుపరచడానికి టైప్ ఉల్లేఖనాలను ఉపయోగించడం ఆ సమయంలో నా ఆలోచనలలో ఒకటి. నేను ప్రోటోటైప్ కంపైలర్‌ను వ్రాసే దశకు చేరుకున్నాను, కానీ టైప్ చెకింగ్ చాలా ఉపయోగకరంగా అనిపించినందున ఈ ఆలోచనను విడిచిపెట్టాను.
నేను శాంటా క్లారాలోని PyCon 2013లో నా ప్రాజెక్ట్‌ని ప్రదర్శించడం ముగించాను. నేను జీవితాంతం పైథాన్ యొక్క దయగల నియంత గైడో వాన్ రోసమ్‌తో కూడా దీని గురించి మాట్లాడాను. అతను నా కస్టమ్ సింటాక్స్‌ను తొలగించి, స్టాండర్డ్ పైథాన్ 3 సింటాక్స్‌తో కట్టుబడి ఉండమని నన్ను ఒప్పించాడు.పైథాన్ 3 ఫంక్షన్ ఉల్లేఖనాలను సపోర్ట్ చేస్తుంది, కాబట్టి నా ఉదాహరణ క్రింది విధంగా తిరిగి వ్రాయబడుతుంది, ఫలితంగా సాధారణ పైథాన్ ప్రోగ్రామ్ వస్తుంది:
def fib(n: int) -> int:
if n <= 1:
return n
else:
return fib(n - 1) + fib(n - 2)నేను కొన్ని రాజీలు చేసుకోవలసి వచ్చింది (మొదట, నేను నా స్వంత వాక్యనిర్మాణాన్ని ఎందుకు కనుగొన్నాను అని నేను సూచించాలనుకుంటున్నాను). ప్రత్యేకించి, ఆ సమయంలో భాష యొక్క ఇటీవలి సంస్కరణ అయిన పైథాన్ 3.3, వేరియబుల్ ఉల్లేఖనాలకు మద్దతు ఇవ్వలేదు. నేను ఇమెయిల్ ద్వారా Guidoతో ఇటువంటి ఉల్లేఖనాల కోసం వివిధ వాక్యనిర్మాణ ఎంపికలను చర్చించాను. మేము వేరియబుల్స్ కోసం టైప్ కామెంట్‌లను ఉపయోగించాలని నిర్ణయించుకున్నాము. ఇది లక్ష్యాన్ని సాధించింది, కానీ కొంచెం గజిబిజిగా అనిపించింది (పైథాన్ 3.6 మాకు చక్కని సింటాక్స్‌ని ఇచ్చింది):
products = [] # type: List[str] # Ewwటైప్ కామెంట్‌లు పైథాన్ 2కి మద్దతు ఇవ్వడానికి కూడా ఉపయోగపడతాయి, ఇందులో టైప్ ఉల్లేఖనాలకు అంతర్నిర్మిత మద్దతు లేదు:
f fib(n):
# type: (int) -> int
if n <= 1:
return n
else:
return fib(n - 1) + fib(n - 2)ఈ (మరియు ఇతర) రాజీలు నిజంగా పట్టింపు లేదని తేలింది - స్టాటిక్ టైపింగ్ యొక్క ప్రయోజనాలు అంటే వినియోగదారులు తక్కువ-పరిపూర్ణ వాక్యనిర్మాణం గురించి త్వరలో మరచిపోయారు. రకాలను నియంత్రించే పైథాన్ కోడ్ ఇకపై ప్రత్యేక సింటాక్స్‌ను ఉపయోగించనందున, ఇప్పటికే ఉన్న పైథాన్ సాధనాలు మరియు కోడ్ ప్రక్రియలు సాధారణంగా పని చేస్తూనే ఉన్నాయి, దీని వలన డెవలపర్లు కొత్త సాధనాన్ని నేర్చుకోవడం చాలా సులభం.
నేను నా సీనియర్ థీసిస్‌ను పూర్తి చేసిన తర్వాత డ్రాప్‌బాక్స్‌లో చేరమని గైడో కూడా నన్ను ఒప్పించాడు. మైపీ చరిత్రలో అత్యంత ఆసక్తికరమైన విషయం ఇక్కడే ప్రారంభమవుతుంది.
కొనసాగించాలి…
ప్రియమైన పాఠకులారా! మీరు పైథాన్‌ని ఉపయోగిస్తుంటే, దయచేసి మీరు ఈ భాషలో అభివృద్ధి చేసే ప్రాజెక్ట్‌ల స్కేల్ గురించి మాకు చెప్పండి.
మూలం: www.habr.com