ផ្លូវទៅកាន់ការវាយអក្សរ 4 លានបន្ទាត់នៃកូដ Python ។ ផ្នែកទី 1

ថ្ងៃនេះ យើងសូមនាំមកជូនលោកអ្នកនូវផ្នែកដំបូងនៃការបកប្រែសម្ភារៈអំពីរបៀបដែល Dropbox ដោះស្រាយជាមួយនឹងការគ្រប់គ្រងប្រភេទកូដ Python ។

Dropbox សរសេរច្រើននៅក្នុង Python ។ វា​ជា​ភាសា​មួយ​ដែល​យើង​ប្រើ​យ៉ាង​ទូលំទូលាយ ទាំង​សម្រាប់​សេវាកម្ម​ផ្នែក​ខាងក្រោយ និង​កម្មវិធី​កម្មវិធី​កុំព្យូទ័រ។ យើងក៏ប្រើ Go, TypeScript និង Rust ច្រើនដែរ ប៉ុន្តែ Python គឺជាភាសាចម្បងរបស់យើង។ ដោយពិចារណាលើមាត្រដ្ឋានរបស់យើង ហើយយើងកំពុងនិយាយអំពីកូដ Python រាប់លានបន្ទាត់ វាបានប្រែក្លាយថាការវាយបញ្ចូលថាមវន្តនៃកូដបែបនេះធ្វើឱ្យមានភាពស្មុគស្មាញដល់ការយល់ដឹងរបស់វា ហើយចាប់ផ្តើមប៉ះពាល់យ៉ាងខ្លាំងដល់ផលិតភាពការងារ។ ដើម្បីកាត់បន្ថយបញ្ហានេះ យើងបានចាប់ផ្តើមផ្លាស់ប្តូរជាបណ្តើរៗនូវកូដរបស់យើងទៅជាការត្រួតពិនិត្យប្រភេទឋិតិវន្តដោយប្រើ mypy ។ នេះប្រហែលជាប្រព័ន្ធត្រួតពិនិត្យប្រភេទដាច់ដោយឡែកដ៏ពេញនិយមបំផុតសម្រាប់ Python ។ Mypy គឺជាគម្រោងប្រភពបើកចំហ អ្នកអភិវឌ្ឍន៍សំខាន់របស់វាធ្វើការនៅក្នុង Dropbox ។

Dropbox គឺជាក្រុមហ៊ុនដំបូងគេដែលអនុវត្តការត្រួតពិនិត្យប្រភេទឋិតិវន្តនៅក្នុងកូដ Python នៅមាត្រដ្ឋាននេះ។ Mypy ត្រូវបានប្រើនៅក្នុងគម្រោងរាប់ពាន់នាពេលបច្ចុប្បន្ននេះ។ ឧបករណ៍នេះរាប់មិនអស់ដូចដែលពួកគេនិយាយថា "បានសាកល្បងនៅក្នុងការប្រយុទ្ធ" ។ យើង​បាន​មក​យ៉ាង​ឆ្ងាយ​ដើម្បី​ទៅ​ដល់​កន្លែង​ដែល​យើង​នៅ​ពេល​នេះ។ នៅតាមផ្លូវ មានកិច្ចការជាច្រើនដែលមិនជោគជ័យ និងការពិសោធន៍បរាជ័យ។ ប្រកាសនេះគ្របដណ្តប់ប្រវត្តិនៃការត្រួតពិនិត្យប្រភេទឋិតិវន្តនៅក្នុង Python ពីការចាប់ផ្តើមដ៏គួរឱ្យភ្ញាក់ផ្អើលរបស់វា ដែលជាផ្នែកមួយនៃគម្រោងស្រាវជ្រាវរបស់ខ្ញុំ រហូតមកដល់សព្វថ្ងៃនេះ នៅពេលដែលការពិនិត្យមើលប្រភេទ និងការបញ្ជាក់ប្រភេទបានក្លាយជារឿងធម្មតាសម្រាប់អ្នកអភិវឌ្ឍន៍រាប់មិនអស់ដែលសរសេរនៅក្នុង Python ។ ឥឡូវនេះយន្តការទាំងនេះត្រូវបានគាំទ្រដោយឧបករណ៍ជាច្រើនដូចជា IDEs និងឧបករណ៍វិភាគកូដ។

→ សូមអានផ្នែកទី ២

ហេតុអ្វីបានជាការត្រួតពិនិត្យប្រភេទចាំបាច់?

ប្រសិនបើអ្នកធ្លាប់ប្រើ Python វាយអក្សរថាមវន្ត អ្នកប្រហែលជាមានការភ័ន្តច្រឡំខ្លះថាហេតុអ្វីបានជាមានការច្របូកច្របល់បែបនេះជុំវិញការវាយអក្សរដោយឋិតិវន្ត និង mypy នាពេលថ្មីៗនេះ។ ឬប្រហែលជាអ្នកចូលចិត្ត Python យ៉ាងជាក់លាក់ដោយសារតែការវាយអក្សរថាមវន្ត ហើយអ្វីដែលកំពុងកើតឡើងធ្វើឱ្យអ្នកខកចិត្ត។ គន្លឹះនៃតម្លៃនៃការវាយអក្សរឋិតិវន្តគឺទំហំនៃដំណោះស្រាយ៖ គម្រោងរបស់អ្នកកាន់តែធំ អ្នកកាន់តែពឹងផ្អែកលើការវាយអក្សរឋិតិវន្ត ហើយនៅទីបញ្ចប់ អ្នកកាន់តែត្រូវការវាកាន់តែច្រើន។

ឧបមាថាគម្រោងជាក់លាក់មួយបានឈានដល់ទំហំរាប់ម៉ឺនបន្ទាត់ ហើយវាបានប្រែក្លាយថាអ្នកសរសេរកម្មវិធីជាច្រើនកំពុងធ្វើការលើវា។ ក្រឡេកមើលគម្រោងស្រដៀងគ្នានេះ ដោយផ្អែកលើបទពិសោធន៍របស់យើង យើងអាចនិយាយបានថាការយល់ដឹងអំពីកូដរបស់វានឹងក្លាយជាគន្លឹះក្នុងការរក្សាផលិតភាពរបស់អ្នកអភិវឌ្ឍន៍។ បើគ្មានចំណារពន្យល់ប្រភេទទេ វាអាចពិបាកក្នុងការស្វែងយល់ ឧទាហរណ៍ តើអាគុយម៉ង់អ្វីខ្លះដែលត្រូវបញ្ជូនទៅកាន់អនុគមន៍ ឬប្រភេទមុខងារណាដែលអាចត្រលប់មកវិញបាន។ នេះគឺជាសំណួរធម្មតាដែលជារឿយៗពិបាកឆ្លើយដោយមិនប្រើចំណារពន្យល់ប្រភេទ៖

• តើមុខងារនេះអាចត្រលប់មកវិញបានទេ។ None?
• តើអាគុយម៉ង់នេះគួរជាអ្វី? items?
• តើអ្វីទៅជាប្រភេទគុណលក្ខណៈ id: int តើវា strឬប្រហែលជាប្រភេទផ្ទាល់ខ្លួនខ្លះ?
• តើអាគុយម៉ង់នេះគួរតែជាបញ្ជីទេ? តើវាអាចទៅរួចទេក្នុងការឆ្លងកាត់ tuple ទៅវា?

ប្រសិនបើអ្នកក្រឡេកមើលអត្ថបទកូដដែលបានរៀបរាប់ពីប្រភេទខាងក្រោម ហើយព្យាយាមឆ្លើយសំណួរស្រដៀងគ្នានេះ វាប្រែថានេះគឺជាកិច្ចការដ៏សាមញ្ញបំផុត៖

class Resource:
    id: bytes
    ...
    def read_metadata(self, 
                      items: Sequence[str]) -> Dict[str, MetadataItem]:
        ...

• read_metadata មិនត្រឡប់មកវិញ Noneចាប់តាំងពីប្រភេទត្រឡប់មកវិញគឺមិនមែន Optional[…].
• អាគុយម៉ង់ items គឺជាលំដាប់នៃបន្ទាត់។ វាមិនអាចត្រូវបានធ្វើម្តងទៀតដោយចៃដន្យទេ។
• គុណលក្ខណៈ id គឺជាខ្សែអក្សរនៃបៃ។

នៅក្នុងពិភពដ៏ល្អមួយ មនុស្សម្នាក់រំពឹងថា subtleties ទាំងអស់នឹងត្រូវបានពិពណ៌នានៅក្នុងឯកសារដែលបានភ្ជាប់មកជាមួយ (docstring)។ ប៉ុន្តែបទពិសោធន៍ផ្តល់នូវឧទាហរណ៍ជាច្រើននៃការពិតដែលថាឯកសារបែបនេះមិនត្រូវបានគេសង្កេតឃើញជាញឹកញាប់នៅក្នុងកូដដែលអ្នកត្រូវធ្វើការ។ ទោះបីជាឯកសារបែបនេះមាននៅក្នុងកូដក៏ដោយ ក៏គេមិនអាចពឹងផ្អែកលើភាពត្រឹមត្រូវទាំងស្រុងរបស់វាបានទេ។ ឯកសារនេះអាចមានភាពមិនច្បាស់លាស់ មិនត្រឹមត្រូវ និងបើកចំហចំពោះការយល់ច្រឡំ។ នៅក្នុងក្រុមធំ ឬគម្រោងធំ បញ្ហានេះអាចក្លាយទៅជាធ្ងន់ធ្ងរបំផុត។

ខណៈពេលដែល Python ពូកែក្នុងដំណាក់កាលដំបូង ឬមធ្យមនៃគម្រោង នៅចំណុចខ្លះ គម្រោងជោគជ័យ និងក្រុមហ៊ុនដែលប្រើ Python អាចនឹងប្រឈមមុខនឹងសំណួរសំខាន់៖ "តើយើងគួរសរសេរអ្វីៗទាំងអស់ឡើងវិញជាភាសាវាយអក្សរស្ថាបត្យកម្មទេ?"។

ប្រព័ន្ធត្រួតពិនិត្យប្រភេទដូចជា mypy ដោះស្រាយបញ្ហាខាងលើដោយផ្តល់ឱ្យអ្នកអភិវឌ្ឍន៍នូវភាសាផ្លូវការសម្រាប់ការពិពណ៌នាអំពីប្រភេទ ហើយដោយពិនិត្យមើលការប្រកាសប្រភេទនោះត្រូវនឹងការអនុវត្តកម្មវិធី (ហើយជាជម្រើសដោយពិនិត្យមើលអត្ថិភាពរបស់វា)។ ជាទូទៅ យើងអាចនិយាយបានថាប្រព័ន្ធទាំងនេះដាក់នៅការចោលរបស់យើង ដូចជាឯកសារដែលបានត្រួតពិនិត្យដោយប្រុងប្រយ័ត្ន។

ការប្រើប្រាស់ប្រព័ន្ធបែបនេះមានគុណសម្បត្តិផ្សេងទៀត ហើយពួកវាគឺមិនសំខាន់ទាំងស្រុងទេ៖

• ប្រព័ន្ធត្រួតពិនិត្យប្រភេទអាចរកឃើញកំហុសមួយចំនួនតូច (និងមិនតូច)។ ឧទាហរណ៍ធម្មតាគឺនៅពេលដែលពួកគេភ្លេចដំណើរការតម្លៃ None ឬលក្ខខណ្ឌពិសេសផ្សេងទៀត។
• ការកែកូដឡើងវិញត្រូវបានសម្រួលយ៉ាងខ្លាំង ពីព្រោះប្រព័ន្ធពិនិត្យប្រភេទមានភាពត្រឹមត្រូវខ្លាំងអំពីអ្វីដែលលេខកូដត្រូវផ្លាស់ប្តូរ។ ក្នុងពេលជាមួយគ្នានេះ យើងមិនចាំបាច់សង្ឃឹមសម្រាប់ការគ្របដណ្តប់កូដ 100% ជាមួយនឹងការធ្វើតេស្ត ដែលក្នុងករណីណាក៏ដោយ ជាធម្មតាមិនអាចទៅរួចនោះទេ។ យើងមិនចាំបាច់ស្វែងយល់ពីជម្រៅនៃដានជង់ ដើម្បីស្វែងរកមូលហេតុនៃបញ្ហានោះទេ។
• សូម្បីតែនៅលើគម្រោងធំក៏ដោយ ជារឿយៗ mypy អាចធ្វើការពិនិត្យប្រភេទពេញលេញក្នុងរយៈពេលមួយវិនាទី។ ហើយការអនុវត្តការធ្វើតេស្តជាធម្មតាចំណាយពេលរាប់សិបវិនាទីឬសូម្បីតែនាទី។ ប្រព័ន្ធត្រួតពិនិត្យប្រភេទផ្តល់ឱ្យអ្នកសរសេរកម្មវិធីនូវមតិកែលម្អភ្លាមៗ និងអនុញ្ញាតឱ្យគាត់ធ្វើការងាររបស់គាត់បានលឿនជាងមុន។ គាត់លែងត្រូវការសរសេរដែលផុយស្រួយ និងពិបាកក្នុងការរក្សាការសាកល្បងឯកតាដែលជំនួសអង្គភាពពិតដោយការចំអក និងបំណះដើម្បីទទួលលទ្ធផលតេស្តកូដលឿនជាងមុន។

IDEs និងអ្នកកែសម្រួលដូចជា PyCharm ឬ Visual Studio Code ប្រើប្រាស់ថាមពលនៃចំណារពន្យល់ប្រភេទ ដើម្បីផ្តល់ឱ្យអ្នកអភិវឌ្ឍន៍នូវការបំពេញកូដ ការបន្លិចកំហុស និងការគាំទ្រសម្រាប់ការបង្កើតភាសាដែលប្រើជាទូទៅ។ ហើយទាំងនេះគ្រាន់តែជាអត្ថប្រយោជន៍មួយចំនួននៃការវាយអក្សរប៉ុណ្ណោះ។ សម្រាប់អ្នកសរសេរកម្មវិធីមួយចំនួន ទាំងអស់នេះគឺជាអាគុយម៉ង់ចម្បងក្នុងការពេញចិត្តក្នុងការវាយ។ នេះគឺជាអ្វីដែលមានប្រយោជន៍ភ្លាមៗបន្ទាប់ពីការអនុវត្ត។ ករណីប្រើប្រាស់នេះសម្រាប់ប្រភេទមិនតម្រូវឱ្យមានប្រព័ន្ធពិនិត្យប្រភេទដាច់ដោយឡែកដូចជា mypy ទេ ទោះបីជាវាគួរតែត្រូវបានកត់សម្គាល់ថា mypy ជួយរក្សាការពន្យល់ប្រភេទឱ្យស្របជាមួយនឹងកូដក៏ដោយ។

ផ្ទៃខាងក្រោយនៃ mypy

ប្រវត្តិនៃ mypy បានចាប់ផ្តើមនៅក្នុងចក្រភពអង់គ្លេស ក្នុងទីក្រុង Cambridge ប៉ុន្មានឆ្នាំមុនពេលដែលខ្ញុំបានចូលរួមជាមួយ Dropbox ។ ខ្ញុំបានចូលរួមជាផ្នែកនៃការស្រាវជ្រាវថ្នាក់បណ្ឌិតរបស់ខ្ញុំ ក្នុងការបង្រួបបង្រួមនៃភាសាដែលបានវាយបញ្ចូលជាស្ថាបត្យកម្ម និងថាមវន្ត។ ខ្ញុំ​ត្រូវ​បាន​បំផុសគំនិត​ដោយ​អត្ថបទ​ស្តី​ពី​ការ​វាយ​បញ្ចូល​ដោយ​លោក Jeremy Siek និង Walid Taha និង​ដោយ​គម្រោង Typed Racket ។ ខ្ញុំបានព្យាយាមស្វែងរកវិធីប្រើភាសាសរសេរកម្មវិធីដូចគ្នាសម្រាប់គម្រោងផ្សេងៗ - ពីស្គ្រីបតូចៗរហូតដល់មូលដ្ឋានកូដដែលមានរាប់លានបន្ទាត់។ ក្នុងពេលជាមួយគ្នានេះ ខ្ញុំចង់ធានាថា នៅក្នុងគម្រោងនៃមាត្រដ្ឋានណាមួយ វានឹងមិនត្រូវធ្វើការសម្របសម្រួលធំពេកនោះទេ។ ផ្នែកសំខាន់មួយនៃការទាំងអស់នេះគឺគំនិតនៃការផ្លាស់ប្តូរបន្តិចម្តង ៗ ពីគម្រោងគំរូដែលមិនបានវាយបញ្ចូលទៅជាផលិតផលសម្រេចដែលបានវាយបញ្ចូលដោយស្ថាបត្យកម្មដែលត្រូវបានសាកល្បងយ៉ាងទូលំទូលាយ។ សព្វថ្ងៃនេះ គំនិតទាំងនេះត្រូវបានទទួលយកយ៉ាងទូលំទូលាយ ប៉ុន្តែនៅក្នុងឆ្នាំ 2010 វាគឺជាបញ្ហាដែលនៅតែត្រូវបានស្វែងរកយ៉ាងសកម្ម។

ការងារដើមរបស់ខ្ញុំក្នុងការត្រួតពិនិត្យប្រភេទគឺមិនមានគោលបំណងលើ Python ទេ។ ផ្ទុយទៅវិញ ខ្ញុំបានប្រើភាសាតូចមួយ "ធ្វើនៅផ្ទះ" អាឡូ. នេះគឺជាឧទាហរណ៍ដែលនឹងអនុញ្ញាតឱ្យអ្នកយល់ពីអ្វីដែលយើងកំពុងនិយាយអំពី (ប្រភេទចំណារពន្យល់គឺស្រេចចិត្តនៅទីនេះ)៖

def Fib(n as Int) as Int
  if n <= 1
    return n
  else
    return Fib(n - 1) + Fib(n - 2)
  end
end

ការប្រើភាសាកំណើតសាមញ្ញគឺជាវិធីសាស្រ្តទូទៅដែលប្រើក្នុងការស្រាវជ្រាវវិទ្យាសាស្ត្រ។ នេះពិតជាដូច្នេះមែន ព្រោះវាអនុញ្ញាតឱ្យអ្នកធ្វើការពិសោធន៍បានយ៉ាងឆាប់រហ័ស ហើយដោយសារតែការពិតដែលថាអ្វីដែលមិនមានជាប់ទាក់ទងនឹងការសិក្សាអាចត្រូវបានគេមិនអើពើយ៉ាងងាយស្រួល។ ភាសាសរសេរកម្មវិធីក្នុងពិភពពិតមានទំនោរទៅជាបាតុភូតទ្រង់ទ្រាយធំជាមួយនឹងការអនុវត្តដ៏ស្មុគស្មាញ ហើយនេះធ្វើឱ្យការពិសោធន៍ថយចុះ។ ទោះជាយ៉ាងណាក៏ដោយ លទ្ធផលណាមួយដែលផ្អែកលើភាសាសាមញ្ញមើលទៅគួរឱ្យសង្ស័យបន្តិច ព្រោះក្នុងការទទួលបានលទ្ធផលទាំងនេះ អ្នកស្រាវជ្រាវប្រហែលជាបានលះបង់ការពិចារណាសំខាន់ៗសម្រាប់ការប្រើប្រាស់ភាសាជាក់ស្តែង។

កម្មវិធីពិនិត្យប្រភេទរបស់ខ្ញុំសម្រាប់ Alore មើលទៅពិតជាមានសំណាងណាស់ ប៉ុន្តែខ្ញុំចង់សាកល្បងវាដោយពិសោធន៍ជាមួយកូដពិត ដែលអ្នកប្រហែលជានិយាយថា មិនត្រូវបានសរសេរនៅក្នុង Alore ទេ។ ជាសំណាងល្អសម្រាប់ខ្ញុំ ភាសា Alore ភាគច្រើនផ្អែកលើគំនិតដូចគ្នានឹង Python ។ វាងាយស្រួលគ្រប់គ្រាន់ក្នុងការបង្កើតម៉ាស៊ីនវាយអក្សរឡើងវិញ ដូច្នេះវាអាចដំណើរការជាមួយវាក្យសម្ព័ន្ធ និងអត្ថន័យរបស់ Python ។ វាអនុញ្ញាតឱ្យយើងសាកល្បងវាយបញ្ចូលកូដ Python ប្រភពបើកចំហ។ លើសពីនេះ ខ្ញុំបានសរសេរ transpiler ដើម្បីបំប្លែងកូដដែលសរសេរក្នុង Alore ទៅជាកូដ Python ហើយប្រើវាដើម្បីបកប្រែកូដអ្នកវាយអក្សររបស់ខ្ញុំ។ ឥឡូវនេះខ្ញុំមានប្រព័ន្ធពិនិត្យប្រភេទដែលសរសេរជាភាសា Python ដែលគាំទ្រផ្នែករងនៃ Python ដែលជាភាសាប្រភេទនោះ! (ការសម្រេចចិត្តផ្នែកស្ថាបត្យកម្មមួយចំនួនដែលយល់បានសម្រាប់ Alore គឺមិនសមស្របនឹង Python ហើយនេះនៅតែអាចកត់សម្គាល់បាននៅក្នុងផ្នែកនៃ mypy codebase ។ )

តាមពិត ភាសាដែលគាំទ្រដោយប្រព័ន្ធប្រភេទរបស់ខ្ញុំមិនអាចត្រូវបានគេហៅថា Python នៅចំណុចនេះទេ៖ វាជាវ៉ារ្យ៉ង់នៃ Python ដោយសារតែដែនកំណត់មួយចំនួននៃវាក្យសម្ព័ន្ធចំណារពន្យល់ប្រភេទ Python 3 ។

វាមើលទៅដូចជាល្បាយនៃ Java និង Python៖

int fib(int n):
    if n <= 1:
        return n
    else:
        return fib(n - 1) + fib(n - 2)

គំនិតមួយរបស់ខ្ញុំនៅពេលនោះគឺត្រូវប្រើការពន្យល់ប្រភេទដើម្បីកែលម្អការអនុវត្តដោយការចងក្រងប្រភេទ Python នេះទៅជា C ឬប្រហែលជា JVM bytecode ។ ខ្ញុំបានឈានដល់ដំណាក់កាលនៃការសរសេរគំរូអ្នកចងក្រង ប៉ុន្តែខ្ញុំបានបោះបង់ចោលគំនិតនេះ ដោយសារការពិនិត្យមើលប្រភេទខ្លួនឯងមើលទៅមានប្រយោជន៍ណាស់។

ខ្ញុំបានបញ្ចប់ការបង្ហាញពីគម្រោងរបស់ខ្ញុំនៅ PyCon 2013 នៅ Santa Clara។ ខ្ញុំក៏បាននិយាយអំពីរឿងនេះជាមួយលោក Guido van Rossum ដែលជាមេដឹកនាំផ្តាច់ការ Python ដ៏សប្បុរសសម្រាប់ជីវិត។ គាត់បានបញ្ចុះបញ្ចូលខ្ញុំឱ្យទម្លាក់វាក្យសម្ព័ន្ធផ្ទាល់ខ្លួនរបស់ខ្ញុំ ហើយនៅជាប់នឹងវាក្យសម្ព័ន្ធស្តង់ដារ Python 3 ។ Python 3 គាំទ្រការពន្យល់អំពីមុខងារ ដូច្នេះឧទាហរណ៍របស់ខ្ញុំអាចត្រូវបានសរសេរឡើងវិញដូចបានបង្ហាញខាងក្រោម ដែលជាលទ្ធផលនៅក្នុងកម្មវិធី Python ធម្មតា៖

def fib(n: int) -> int:
    if n <= 1:
        return n
    else:
        return fib(n - 1) + fib(n - 2)

ខ្ញុំត្រូវតែធ្វើការសម្របសម្រួលមួយចំនួន (ជាដំបូងខ្ញុំចង់កត់សម្គាល់ថាខ្ញុំបានបង្កើតវាក្យសម្ព័ន្ធផ្ទាល់ខ្លួនរបស់ខ្ញុំសម្រាប់ហេតុផលនេះ) ។ ជាពិសេស Python 3.3 ដែលជាកំណែចុងក្រោយបំផុតនៃភាសានៅពេលនោះ មិនគាំទ្រការពន្យល់អថេរទេ។ ខ្ញុំបានពិភាក្សាជាមួយលោក Guido តាមអ៊ីមែលអំពីលទ្ធភាពផ្សេងៗសម្រាប់ការរចនាវាក្យសម្ព័ន្ធនៃចំណារពន្យល់បែបនេះ។ យើងបានសម្រេចចិត្តប្រើមតិយោបល់ប្រភេទសម្រាប់អថេរ។ វាបានបម្រើគោលបំណងដែលបានគ្រោងទុក ប៉ុន្តែមានការពិបាកបន្តិច (Python 3.6 ផ្តល់ឱ្យយើងនូវវាក្យសម្ព័ន្ធល្អជាង)៖

products = []  # type: List[str]  # Eww

មតិយោបល់ប្រភេទក៏មានប្រយោជន៍ផងដែរក្នុងការគាំទ្រ Python 2 ដែលមិនមានការគាំទ្រសម្រាប់ប្រភេទចំណារពន្យល់៖

f fib(n):
    # type: (int) -> int
    if n <= 1:
        return n
    else:
        return fib(n - 1) + fib(n - 2)

វាបានប្រែក្លាយថាការដោះដូរពាណិជ្ជកម្មទាំងនេះ (និងផ្សេងទៀត) ពិតជាមិនសំខាន់ទេ - អត្ថប្រយោជន៍នៃការវាយអក្សរឋិតិវន្តមានន័យថាអ្នកប្រើប្រាស់ឆាប់ភ្លេចអំពីវាក្យសម្ព័ន្ធដែលមិនសូវល្អឥតខ្ចោះ។ ដោយសារគ្មានការស្ថាបនាវាក្យសម្ព័ន្ធពិសេសណាមួយត្រូវបានប្រើប្រាស់នៅក្នុងកូដ Python ដែលបានពិនិត្យប្រភេទនោះ ឧបករណ៍ Python ដែលមានស្រាប់ និងដំណើរការដំណើរការកូដបន្តដំណើរការជាធម្មតា ដែលធ្វើឱ្យវាកាន់តែងាយស្រួលសម្រាប់អ្នកអភិវឌ្ឍន៍ក្នុងការរៀនឧបករណ៍ថ្មី។

Guido ក៏បានបញ្ចុះបញ្ចូលខ្ញុំឱ្យចូលរួមជាមួយ Dropbox បន្ទាប់ពីខ្ញុំបានបញ្ចប់និក្ខេបបទបញ្ចប់ការសិក្សារបស់ខ្ញុំ។ នេះគឺជាកន្លែងដែលគួរឱ្យចាប់អារម្មណ៍បំផុតនៃរឿង mypy ចាប់ផ្តើម។

នៅ​មាន​ជា​បន្ត​ទៀត…

អ្នកអានជាទីស្រឡាញ់! ប្រសិនបើអ្នកប្រើ Python សូមប្រាប់យើងអំពីមាត្រដ្ឋាននៃគម្រោងដែលអ្នកបង្កើតជាភាសានេះ។

ប្រភព: www.habr.com