ភាសាសរសេរកម្មវិធី Python: រង្វិលជុំ

នេះជា ភាសាសរសេរកម្មវិធី Python (ជា "python" ឬ "python") មានវិធីជាច្រើនដើម្បីរង្វិលជុំសកម្មភាពមួយចំនួន។ ឧបករណ៍សំខាន់សម្រាប់ការអនុវត្តនៃការនិយាយឡើងវិញណាមួយនៅក្នុង Python - ខណៈពេលរង្វិលជុំនិងសម្រាប់។ រង្វិលជុំខណៈពេលនេះគឺមានជាច្រើនទៀតជាសកលជាង, ដូច្នេះវាជាការយឺត។ ទោះយ៉ាងណានេះមិនមែនមានន័យថាវាជាការល្អប្រសើរជាងមុន! សម្រាប់រង្វិលជុំត្រូវបានគេប្រើកាន់តែច្រើនជាញឹកញាប់ដោយសារតែជាមួយវាដឹងថាភារកិច្ចការលំបាកបំផុតសម្រាប់ការបង្កើតពហុកម្រិតនិងកម្មវិធី mnogouslovnyh នេះ។

ពស់ថ្លាន់: វដ្តជាមួយ postcondition

វដ្តជាមួយ postcondition - វារង្វិលជុំ ខណៈពេលដែលមានរចនាសម្ព័ន្ធរបស់អង្គការទូទៅបំផុតនៅក្នុង បរិស្ថានសរសេរកម្មវិធី។ រង្វិលជុំខណៈពេលដែលដំណើរការនៅលើគោលការណ៍នៃការ "ជាយូរមកហើយថាជា" ។ នេះមានន័យដូចខាងក្រោម: ខណៈពេលលក្ខខណ្ឌជាក់លាក់មួយនឹងត្រឡប់ជាតម្លៃពិតវានឹងធ្វើការ! ការរចនានេះត្រូវបានគេហៅថា "វដ្ត" ដោយសារតែមុខងារនៃការគ្រប់គ្រងចរន្តម្តងហើយម្តងទៀតដោយចាប់ផ្តើមតម្លៃដំបូង។ ចេញនៅក្នុងវដ្តនេះខណៈពេលដែល Python បានត្រូវបានអនុវត្តនៅពេលដែលបានក្លាយទៅជាមិនពិតតម្លៃ។ នៅចំណុចនេះ, អ្នកបកប្រែបញ្ជូនកម្មវិធីនឹងផ្នែកមុខងារ-semantic ដូចខាងក្រោមនេះពោលគឺបន្ទាត់ថ្មីមួយដែលមានទីតាំងស្ថិតនៅបន្ទាប់ពីប្លុកជាមួយខណៈពេល postcondition នេះ។

នៅក្នុងភាសាសរសេរកម្មវិធី Python បានខណៈពេល postcondition វដ្តដែលមានវាក្យសម្ពន្ធខាងក្រោម:

ការបញ្ចេញមតិទាំងសេចក្តីថ្លែងការណ៍អាចមានមួយឬច្រើនតែមួយ។ ជម្ងឺនេះគឺតែងតែជាការពិតនៃណាមួយសារៈសំខាន់មិនសូន្យ។ ការរចនានេះធ្វើការជាយូរមកហើយថាជាលក្ខខណ្ឌដែលបានបញ្ជាក់គឺជាការពិត។

ការប្រើវដ្តខណៈពេលដែលនៅក្នុង "python" ឧទាហរណ៍

Rassmotirim ខណៈពេលរង្វិលជុំ។ ពស់ថ្លាន់គួរឱ្យចាប់អារម្មណ៍ណាស់គឺរចនាសម្ព័ន្ធរបស់ខ្លួនអន្តរកម្ម:

យើងបានប្រកាសអថេរ "មួយ" ហើយបានសុំនាងទៅសូន្យ។ បន្ទាប់មកកំណត់លក្ខខណ្ឌ "ខណៈពេលមួយដែល <7", នោះគឺខណៈពេលអថេរ "មួយ" គឺតិចជាង ចំនួននេះ "7", បន្ទាប់មករង្វិលជុំរបស់យើងនឹងត្រូវបានប្រតិបត្តិដែលវែងដូចដែលមានគឺមិនពិត។

ការមិនពិត (នោះគឺនឹងចេញពីវដ្តនេះ) វានឹងត្រូវបាននៅពេលអថេរនេះនឹងមានចំនួនច្រើនជាងចំនួន "7" ។ ចំពោះការនេះកើតឡើង, វាគឺជាពេលវេលាដែលបានបង្កើនម្តងរៀងរាល់ 1 ដែលយើងបានចង្អុលបង្ហាញនៅក្នុង "មួយ = a + 1" ។

ប្រសិនបើអ្នករត់ការសាងសង់នេះ, អក្សរ "A" នឹងត្រូវបានបង្ហាញក្នុងជួរឈរ 7 ដងក្នុងមួយ!

រង្វិលជុំគ្មានទីបញ្ចប់ខណៈពេលដែលនៅក្នុង Python

តើធ្វើដូចម្តេចដើម្បីធ្វើឱ្យរង្វិលជុំគ្មានទីបញ្ចប់នៅក្នុង Python ខណៈពេល? ទាយមិនមានការលំបាកដោយសារតែវដ្តនៃការរត់រហូតដល់រហូតដល់វាទទួលបានតម្លៃមិនពិតហើយប្រសិនបើតម្លៃនេះគឺគ្រាន់តែមិនមាន? ចម្លើយទៅនឹងសំណួរនេះគឺប្រហែលជារួចទៅហើយដូច្នេះអ្វីគ្រប់យ៉ាងគឺច្បាស់លាស់។ នៅក្នុងករណីមួយចំនួន, រង្វិលជុំមិនកំណត់គឺត្រូវបានត្រូវការដើម្បីដោះស្រាយបញ្ហាមួយ? ឧទាហរណ៍នេះនឹងបម្រើជាការសម្រេចបាននៃកម្មវិធីដូចជាថាជា«នាឡិកា»។ ខាងក្រោមនេះជាការពិតណាស់អ្នកត្រូវប្រើរង្វិលជុំមិនកំណត់ដែលនឹងត្រូវបានធ្វើឱ្យទាន់សម័យជារៀងរហូតនិងបង្ហាញពេលវេលា។

រង្វិលជុំមិនកំណត់ជាញឹកញាប់ជាអ្នកសរសេរកម្មវិធីដើម្បីសុខភាពកំហុសដែលភ្លេចបន្ថែមលក្ខខណ្ឌការផ្លាស់ប្តូរវដ្ត។

សូមមើលនៅខាងក្រោមនៃកូដដុំ Python បានមួយ។ វដ្តនៅក្នុងករណី iterated គ្មានកំណត់នេះ (បន្ទាប់ពី "#" តួអក្សរគឺមតិយោបល់):

កម្មវិធីបែបនេះមិនគួរប្រញាប់ប្រញាល់ដើម្បីចងក្រងព្រោះវានឹងដំណើរការជារៀងរហូត។ យើងបានស្នើលក្ខខណ្ឌដូចថានឹងមិនជាតម្លៃមិនពិតស្ថានភាព«ចំនួន <10 "នៅក្នុងករណីនេះនិងតែងតែជាការពិត, ដូច្នេះការនិយាយឡើងវិញនឹងត្រូវបាននាំយកនូវចំនួន N ជានិច្ចទីនៃ" "សារជំរាបសួរ។ ក្នុងគោលបំណងដើម្បីបញ្ឈប់ដំណើរការនៃការចងក្រងអស់កល្បជានិច្ចនោះអ្នកនឹងត្រូវការចុចបន្សំគ្រាប់ចុចបញ្ជា + C ក្នុងសែល។

ពស់ថ្លាន់: វាក្យសម្ព័ន្ធ។ ខណៈពេលហើយសម្រាប់រង្វិលជុំ

ដូចដែលបានរៀបរាប់ខាងលើនៅក្នុងភាសានៃ "python" កម្មវិធីនេះមានវិធីជាច្រើនដើម្បីរៀបចំកន្សោមជាក្រុមម្តងទៀតមាន។ វាមកដល់ការជួយសង្គ្រោះ រង្វិលជុំសម្រាប់, ដែលជាភាពខុសគ្នាបន្តិចពីខណៈពេលដែលដៃគូរបស់ខ្លួនដោយសារតែការរចនារបស់វាគឺតូចមួយបន្ថែមទៀតមានភាពស្មុគស្មាញជាងគ្រាន់តែ postcondition ។ សូមកុំនិយាយពីសកលភាពនៃវដ្តនេះទេព្រោះវាគ្រាន់តែមិនបាន, ទោះជាយ៉ាងណា, ត្រូវបានកត់សម្គាល់ថាសម្រាប់ការរង្វិលជុំគឺលឿនជាងច្រើនខណៈពេលដែលមួយ។ ភាពខុសគ្នានៃវិធីមួយដើម្បីដោះស្រាយការរចនានិងការអនុវត្តនៃវដ្តទង្វើរបស់ Facebook នេះតិចតួចជាមួយ postcondition ដូច្នេះវាទំនងជាបានប្រើដើម្បីអនុវត្តភារកិច្ចតូចតាចជាច្រើនជាច្រើនទៀត។

តើអ្វីទៅជាបញ្ហាប្រឈមដែលប្រឈមនឹងវដ្តសម្រាប់អ្វីខ្លះ? សង្ស័យដូចគ្នាថាការនៃការខណៈពេលដែល - របៀបដូចគ្នាដំណើរការណាមួយឡើយ។ ឯកសារកម្មវិធីដែលបានធ្វើនៅលើ "python" កម្មវិធីត្រូវបានគេប្រើយ៉ាងទូលំទូលាយរង្វិលជុំសម្រាប់ការដែលមានសមត្ថភាពក្នុងការអនុវត្តឆ្លងកាត់បានកំណត់ទុកជាមុនពហុភាពនៃធាតុនិងដើម្បីសម្តែងនៅក្នុងរាងកាយជាច្រើនរបស់ខ្លួន iterating លើពួកវា។ លក្ខណៈពិសេសនៃការរចនានេះអាចត្រូវបានប្រើនៅក្នុងបន្ទាត់ដំណើរការឬបញ្ជីគ្រាន់តែដូចជាវត្ថុណាមួយផ្សេងទៀត iterated ។

ឧទាហរណ៍នៃការប្រើប្រាស់សម្រាប់ការវដ្តនៅក្នុង Python នេះ

សូមឱ្យយើងបាននិយាយថាយើងមានបញ្ជីមួយចំនួននៃចំនួនលេខហើយយើងត្រូវធាតុគ្នា (ឧ។ អ៊ីចំនួន) បានកើនឡើងចំនួនបីគ្រឿង។ ដើម្បីអនុវត្តដូចភារកិច្ចដែលយើងអាចធ្វើតាមរយៈរង្វិលជុំសម្រាប់វិធីសាស្រ្តរង្វិលជុំ។

តោះមើលឧទាហរណ៍រហ័ស, ដែលជាកន្លែងដែលយើងនឹងអនុវត្តវិធានការសមស្របសម្រាប់នេះ (បន្ទាប់ពី "#" តួអក្សរគឺមតិយោបល់):

លទ្ធផលនៃការសាងសង់ខាងលើនេះនឹងត្រូវបាន:

នៅក្នុងឧទាហរណ៍របស់យើងគឺមានការរាប់អថេរដែលយើងត្រូវការដើម្បីផ្លាស់ប្តូរដើម្បីអបអរតម្លៃក្នុងអារេដែលបាន« spisok_chisel »។ ចំនួនអថេរត្រូវបានកត់ត្រាតម្លៃលិបិក្រមនៃធាតុអារេគ្នាក្នុង (ចំនួនគ្នានៅក្នុងបញ្ជី) ។ អថេរ«ធាតុ»តភ្ជាប់តម្លៃលទ្ធផលនៅក្នុងបញ្ជី។ រង្វិលជុំនៅក្នុងសម្រាប់យើងមើលឃើញពីរបៀបដើម្បីអនុវត្តដំណើរការនៃវត្ថុនីមួយក្នុងបញ្ជីលេខ។ នៅខាងក្នុងរង្វិលជុំគ្នាជាមួយនឹងវត្ថុលេខសន្ទស្សន៍«រាប់»បានបន្ថែមទៀតថាចំនួនទឹកប្រាក់នៃធាតុការនិយាយឡើងវិញបច្ចុប្បន្ននិងបីនាក់។ បន្ទាប់មកសន្ទស្សន៍របស់យើង«រាប់»បានកើនឡើងមួយ, និងលំហូរនៃការអនុវត្តកម្មវិធីនេះត្រឡប់ទៅចាប់ផ្តើមនៃការផ្សព្វផ្សាយពាណិជ្ជកម្មសំណង់សម្រាប់។ ដូច្នេះរង្វិលជុំនឹងដំណើរការរហូតដល់រហូតដល់វាត្រូវបានកែច្នៃធាតុគ្នានៅក្នុងអារេដែលបានផ្ដល់ឱ្យដោយជម្ងឺនេះ។ បើធាតុណាមួយគឺបាត់ទេតែត្រូវបានកំណត់ដោយលក្ខខណ្ឌនេះវដ្តបានបញ្ចប់។ យើងគូរយកចិត្តទុកដាក់ទៅរឿងមួយបន្ថែមទៀត: ប្រសិនបើអ្នកមិនបានសរសេរបន្ទាត់នៃ«រាប់ជា = COUNT + 1 "បើទោះបីជាការពិតដែលថាអារេនៃវត្ថុដែលបានដំណើរការដោយជោគជ័យជាមួយលទ្ធផលនឹងតែងតែត្រូវបានបន្ថែមទៅសន្ទស្សន៍របស់វត្ថុលេខដំបូងសូន្យគនេះ។

ឥឡូវនេះយើងអាចគិតអំពីគោលការណ៍ប្រតិបត្ដិការរង្វិលជុំខណៈពេលកំណត់អត្តសញ្ញាណភាពខុសគ្នានិង (រំលឹកថានៅក្នុង Python ចេញពីវដ្តជាមួយ postcondition ត្រូវបានអនុវត្តនៅលើមូលដ្ឋាននៃលក្ខណៈវិនិច្ឆ័យឡូជីខល - ពិត (វដ្តនេះនៅតែបន្ត) ឬមិនពិត (វដ្តឈប់)) ។

តើធ្វើដូចម្តេចដើម្បីព្យាបាលខ្សែអក្សរមួយនៅក្នុង Python ការប្រើការរចនាសម្រាប់?

ក្នុងភាសាសរសេរកម្មវិធីជារៀងរាល់មានវដ្ត, ហើយពួកគេធ្វើការជាធម្មតានៅលើគោលការណ៍ដូចគ្នានេះ, ភាពខុសគ្នាដែលអាចមើលឃើញតែនៅក្នុងវាក្យសម្ព័ន្ធ។ ទោះជាយ៉ាងណាសម្រាប់ការរង្វិលជុំនៅក្នុងភាសា "python" គឺជាការមិនធម្មតានិងការធម្មតា, ដោយសារតែគោលការណ៍នៃការប្រតិបត្ដិការរបស់ខ្លួនគឺមិនត្រូវបានកំណត់ទៅជារាប់។ ការរចនានេះ enumerates ធាតុនីមួយដោយឡែកពីគ្នា។ ទាំងអស់នេះអាចត្រូវបានពន្យល់យ៉ាងងាយស្រួលដោយឧទាហរណ៍មួយនៃការធ្វើការជាមួយខ្សែអក្សរនេះប៉ុន្តែជាដំបូងអនុញ្ញាតឱ្យដោះស្រាយជាមួយនឹងសមាសភាពនៃវដ្តសម្រាប់នេះ:

សម្រាប់អថេរ

វាត្រូវបានរក្សាទុកនៅក្នុងប្រតិបត្ដិការជាវដ្តមួយលទ្ធផលអថេរ

នៅ peremennaya_2

គន្លឹះពាក្យ«នៅ» - វាជាលក្ខណៈមួយនៅពេលដែលធ្វើការជាមួយ«សម្រាប់»វដ្ត។ យើងទាញពី peremennoy_2 តម្លៃដែលនឹងត្រូវបាន iterated នេះ។ ចំពោះភាពច្បាស់លាស់និងភាពច្បាស់លាស់, សូមមើលនៅឧទាហរណ៍តូចមួយនៃរបៀបធ្វើការនិងដើម្បីតម្រៀបខ្សែអក្សរជាមួយ Python:

លទ្ធផលនៃស្គ្រីបនេះ:

សេចក្តីថ្លែងការណ៍បន្ត

ប្រតិបត្តិករបន្តការផ្លាស់ប្តូរដើម្បីអនុវត្តការអនុវត្តន៍នៃវដ្តបន្ទាប់, ដែលបានផ្ដល់ឱ្យដោយលក្ខខណ្ឌមិនគិតពីតុល្យភាពនៃរង្វិលជុំ។ សេចក្តីថ្លែងការណ៍នេះបានបន្តប្រើអាចនៅក្នុងវដ្តពីរ - និងខណៈពេល។

សូមពិចារណាឧទាហរណ៍នេះ:

ជាលទ្ធផលនឹងមានដូចខាងក្រោម:

នៅពេលដែលការដោះស្រាយនេះបានរកឃើញលិខិតមួយ "o" នៅក្នុងខ្សែអក្សរ 'ធ្វើម្តងទៀតលិខិតគ្នា, លើកលែងតែសម្រាប់' ការប្រតិបត្តិនៃកម្មវិធីនេះត្រូវបានបញ្ជូនបន្តភ្លាមទៅបន្ទាត់បន្ទាប់ពីពាក្យ '' បន្ត '', ដែលជាកន្លែងដែលជំងឺនេះត្រូវបានគេកំណត់ដើម្បីចម្លងលិខិតគ្នា។

សេចក្តីថ្លែងការណ៍សម្រាក

ពាក្យគន្លឹះ«សម្រាក»ដែលបានបញ្ចូលនៅកន្លែងដែលវដ្តនេះគឺត្រូវបានរំខានដោយមិនរង់ចាំសម្រាប់ការបញ្ចប់របស់ខ្លួនដែលត្រូវបានផ្តល់ឱ្យដោយជម្ងឺនេះ។ ការរចនានេះត្រូវបានប្រើជាញឹកញាប់នៅពេលសរសេរកម្មវិធីជាមួយនឹងជាច្រើននៃតក្កនិងលក្ខខណ្ឌមួយ។

សូមពិនិត្យមើលគំរូតូចមួយនៃសេចក្តីថ្លែងការណ៍សម្រាកការងារ:

ជាលទ្ធផលនឹងមានដូចខាងក្រោម:

នៅពេលដែលការដោះស្រាយនេះបានរកឃើញលិខិតមួយ "o" នៅក្នុងខ្សែអក្សរ 'ការធ្វើឡើងវិញលើកលែងតែគ្រប់លិខិតសម្រាប់' ការប្រតិបត្តិនៃកម្មវិធីនេះត្រូវបានផ្អាកជាបន្ទាន់ទោះបីជាការពិតដែលថាបន្ទាត់បន្ទាប់មានមួយចំនួននៃលក្ខខណ្ឌសម្រាប់វដ្តនេះ។

ពាក្យវេទមន្តផ្សេងទៀត

នៅក្នុងស៊េរីនៃប្រភេទណាមួយអាចអនុវត្តប្រតិបត្តិករផ្សេងទៀត។ វាគឺសម្រាប់អ្វី? លោកបានត្រួតពិនិត្យដែលត្រូវបានប្តេជ្ញាចិត្តចេញពីរង្វិលជុំនេះមានន័យថាការសម្រាកមួយឬវិធីធម្មតា។ រារាំងការជាមួយនឹងក្បួនដែលបានកំណត់ទុកជាមុនក្នុងការអនុវត្តផ្សេងទៀតចាប់ផ្តើមតែប៉ុណ្ណោះនៅពេលលក្ខខណ្ឌដែលទិន្នផលនៃវដ្តនេះត្រូវបានអនុវត្តដោយគ្មានការប្រើប្រាស់នៃការរចនាសម្ព័សម្រាក។

សូមពិចារណាឧទាហរណ៍តូចមួយ:

លទ្ធផលនៃស្គ្រីបនេះ:

ឧទាហរណ៍នៃវដ្តនៅក្នុងលំដាប់បញ្ច្រាសនៃការភាសាសរសេរកម្មវិធី Python

ក្នុងនាមជាអ្នកអនុវត្តនៅក្នុង Python វដ្តបញ្ច្រាស? សូមឱ្យយើងស្រមៃថាការសរសេរកម្មវិធីមួយដែលត្រូវទទួលស្គាល់បន្ទាត់តួអក្សរនិងបោះពុម្ពក្នុងលំដាប់បញ្ច្រាសមួយ។ តើធ្វើដូចម្តេចដើម្បីអនុវត្តនេះ?

សូមពិចារណាអំពីឧទាហរណ៍ដូចខាងក្រោមនេះ:

លទ្ធផលនៃស្គ្រីបនេះ:

រង្វិលជុំខាងក្នុង

នៅក្នុង Python, មានវដ្តនៃការសរសេរកម្មវិធីផងដែរនិងការវិនិយោគដែលត្រូវបានដាក់ក្នុងរូបកាយរបស់មួយផ្សេងទៀត។ នៅក្នុងវដ្តគ្នាអាចក្លាយជាការរង្វិលជុំខាងក្នុងហើយដូច្នេះវាគឺអាចធ្វើបានដើម្បីកសាងជណ្តើរមួយទៅក្រុមហ៊ុន Infinity ។ នៅក្នុងការនិយាយឡើងវិញជាលើកដំបូងនៃរង្វិលជុំខាងក្រៅត្រូវបានគូរជាមួយនឹងការអំពាវនាវឱ្យមានរង្វិលជុំខាងក្នុងដែលត្រូវបានប្រតិបត្តិមុនពេលការបញ្ចប់របស់ខ្លួនគេផ្ទាល់មួយ, បន្ទាប់មកត្រួតពិនិត្យទាំងអស់បានប្ដូរទិសទៅក្នុងរាងកាយនៃរង្វិលជុំខាងក្រៅនេះ។ ភាសាទាំងអស់មានលក្ខណៈផ្ទាល់របស់ខ្លួននៃរង្វិលជុំខាងក្នុង, សូមមើលរបៀបដែលពួកគេធ្វើការនៅក្នុងភាសាសរសេរកម្មវិធី "python" ។

ប្រសិនបើអ្នកកំពុងប្រើរង្វិលជុំខាងក្នុង, Python បានផ្តល់នូវវាក្យសម្ពន្ធខាងក្រោម:

លក្ខណៈពិសេសនៃរង្វិលជុំខាងក្នុងគឺជាការពិតដែលថានៅក្នុងវដ្តនៃប្រភេទណាមួយដែលអាចត្រូវបានប្រើជាប្រភេទនៃវដ្តណាមួយនោះ! នេះមានន័យថានៅក្នុងវដ្តមួយខណៈពេលដែល (ឬ) អាចត្រូវបានបង្កប់សម្រាប់ការវដ្តថ្មីម្តងទៀតខណៈពេលមួយឬនិងច្រាសមកវិញ។