ខណៈពេលដែលរង្វិលជុំនៅក្នុង Python ។ របៀបដែលវាដំណើរការ, ឧទាហរណ៍នៃការប្រើប្រាស់

រង្វិលជុំគឺជាឧបករណ៍សំខាន់មួយនៃភាសាណាមួយ។ មានរង្វិលជុំជាមូលដ្ឋានចំនួនពីរនៅក្នុង Python ដែលមួយក្នុងចំណោមនោះគឺខណៈពេលដែល។ សូមពិចារណាវា និងសម្រាប់ការយល់ដឹងកាន់តែច្បាស់អំពីរូបភាពមួយបន្ថែមទៀត។ ជាការពិតណាស់ ក្នុងការប្រៀបធៀបជាមួយអ្វីដែលស្រដៀងគ្នា វាកាន់តែងាយស្រួលក្នុងការយល់អំពីសម្ភារៈណាមួយ មែនទេ?

គំនិតនៃវដ្តមួយ។

ត្រូវការរង្វិលជុំនៅពេលដែលសកម្មភាពជាក់លាក់មួយត្រូវធ្វើច្រើនដង។ នេះគឺសាមញ្ញណាស់ ពីព្រោះតាមពិត ជួរនៃកម្មវិធីសម្រាប់វដ្តគឺធំទូលាយជាង។ មានរង្វិលជុំពីរប្រភេទសំខាន់ៗនៅក្នុង Python: សម្រាប់ និងខណៈពេល។ ការពេញនិយមបំផុតគឺសម្រាប់។

បន្ថែមពីលើសកម្មភាពជាក់លាក់ អ្នកអាចរង្វិលជុំបំណែកផ្សេងៗនៃកូដរហូតដល់ចំណុចជាក់លាក់មួយ។ នេះអាចជាចំនួនដងជាក់លាក់ ឬដរាបណាលក្ខខណ្ឌជាក់លាក់ណាមួយជាការពិត។

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

វដ្តសម្រាប់

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

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

>>> spisok = [10, 40, 20, 30]

>>> សម្រាប់ធាតុនៅក្នុង spisok:

… បោះពុម្ព (ធាតុ + 2)

...

12

42

22

32

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

ក្នុងករណីរបស់យើងបញ្ជីគឺជាលំដាប់នៃលេខ 10,40,20,30 ។ នៅពេលធ្វើឡើងវិញនីមួយៗ តម្លៃដែលត្រូវគ្នានឹងបង្ហាញនៅក្នុងអថេរ។ ឧទាហរណ៍ ដរាបណារង្វិលជុំចាប់ផ្តើម អថេរ ធាតុ តម្លៃ 10 ត្រូវបានកំណត់។ នៅថ្ងៃបន្ទាប់ លេខដប់ប្រែទៅជាលេខ 40 លើកទីបីវាប្រែទៅជាលេខ 20 ហើយចុងក្រោយនៅលើរង្វិលជុំចុងក្រោយវាប្រែទៅជា 30 ។

សញ្ញាសម្រាប់ការបញ្ចប់នៃវដ្តគឺជាការបញ្ចប់នៃធាតុនៅក្នុងបញ្ជី។

ប្រសិនបើអ្នកត្រូវការរង្វិលជុំដើម្បីអនុវត្តការរាប់លេខបុរាណនៃតម្លៃ ដូចជានៅក្នុងភាសាសរសេរកម្មវិធីផ្សេងទៀត អ្នកគួរតែបង្កើតបញ្ជីជាមួយនឹងលំដាប់នៃលេខធម្មជាតិរហូតដល់តម្លៃដែលយើងត្រូវការ។

>>> spisok = [1,2,3,4,5]

ឬប្រើមុខងារ លេន(), ដើម្បីកំណត់ប្រវែងបញ្ជី។ ប៉ុន្តែក្នុងករណីនេះវាជាការប្រសើរក្នុងការប្រើរង្វិលជុំ ខណៈពេលដែល ព្រោះមិនចាំបាច់ប្រើអថេរទេ។

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

ខណៈពេលដែលរង្វិលជុំ

មិនដូចវដ្ត សម្រាប់ដែលគ្រាន់តែធ្វើម្តងទៀតលើតម្លៃនៃលំដាប់ រង្វិលជុំ ខណៈពេល មានការប្រើប្រាស់កាន់តែច្រើន។ ឈ្មោះនៃប្រភេទនៃវដ្តនេះត្រូវបានបកប្រែជា "នៅឡើយទេ" ។ នោះគឺ "រហូតដល់" ។

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

ប្រសិនបើយើងគូររង្វង់ ខណៈពេល សាមញ្ញ នេះត្រូវបានធ្វើដោយប្រើគ្រោងការណ៍បែបនេះ។

សាខាសំខាន់នៃកម្មវិធី (ដែលដំណើរការនៅខាងក្រៅរង្វិលជុំ) ត្រូវបានបង្ហាញនៅក្នុងតួលេខនេះជាមួយនឹងចតុកោណពណ៌ខៀវ។ Turquoise តំណាងឱ្យរាងកាយនៃវដ្ត។ នៅក្នុងវេន, rhombus គឺជាលក្ខខណ្ឌមួយដែលត្រូវបានពិនិត្យនៅការកើតឡើងម្តងទៀត។

វដ្ត ខណៈពេល អាចបណ្តាលឱ្យមានការលើកលែងពីរ:

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

វាអាចមានជម្រើសជាច្រើនសម្រាប់របៀបដោះស្រាយកំហុស។ ឧទាហរណ៍ កម្មវិធីអាចស្នើឱ្យអ្នកប្រើប្រាស់បញ្ចូលទិន្នន័យឱ្យបានត្រឹមត្រូវ។ ដូច្នេះ ប្រសិនបើមនុស្សម្នាក់បានចង្អុលបង្ហាញលេខអវិជ្ជមាន ដែលវាអាចគ្រាន់តែជាលេខវិជ្ជមាន ឬបញ្ចូលអក្សរដែលមានតែលេខប៉ុណ្ណោះ កម្មវិធីអាចប្រាប់អំពីវាបាន។

ខណៈពេលដែលឧទាហរណ៍រង្វិលជុំ

នេះគឺជាឧទាហរណ៍នៃកូដដែលដោះស្រាយកំហុសក្នុងករណីនេះ។

n = input("បញ្ចូលចំនួនគត់៖") 

ខណៈពេលដែល type(n) != int:

    ព្យាយាម:

        n = int(n)

    លើកលែងតែតម្លៃកំហុស៖

        បោះពុម្ព ("ការបញ្ចូលខុស!")

        n = input("បញ្ចូលចំនួនគត់៖") 

ប្រសិនបើ n % 2 == 0:

    បោះពុម្ព ("គូ")

ផ្សេងទៀត:

    បោះពុម្ព ("សេស")

សូមចងចាំថា Python ប្រើសញ្ញាសម្គាល់ដើម្បីប្រកាសកូដស្មុគស្មាញ។

ក្នុង​កូដ​ខាងលើ​យើង​កំណត់​ជា​លក្ខខណ្ឌ​ដែល​យើង​គួរ​ពិនិត្យ​មើល​ថា​តើ​លេខ​នោះ​ជា​ចំនួន​គត់​ឬ​អត់។ ប្រសិនបើបាទ/ចាស នោះមិនពិតនឹងត្រលប់មកវិញ។ បើមិនអញ្ចឹងមែនពិត។

នៅក្នុងផ្នែកទីពីរនៃកូដដែលប្រតិបត្តិករត្រូវបានប្រើ ifយើងបានប្រើប្រតិបត្តិករ % ដើម្បីស្វែងរកនៅសល់បន្ទាប់ពីប្រតិបត្តិការផ្នែក។ ជំហានបន្ទាប់គឺត្រូវពិនិត្យមើលថាតើលេខស្មើឬអត់។ បើមិនដូច្នោះទេ នៅសល់គឺមួយក្នុងករណីនេះ។ ដូច្នោះហើយចំនួនគឺសេស។ 

ក្នុងន័យសាមញ្ញ លេខកូដខាងលើពិនិត្យជាមុនសិន ថាតើខ្សែអក្សរដែលបានបញ្ចូលដោយអ្នកប្រើប្រាស់គឺជាលេខ។ ប្រសិនបើបាទ/ចាស ការត្រួតពិនិត្យលើកទីពីរត្រូវបានធ្វើឡើងដើម្បីមើលថាតើនៅសល់នៃការបែងចែកដោយពីរឬអត់។ ប៉ុន្តែប្លុកទីពីរនឹងមិនត្រូវបានប្រតិបត្តិរហូតដល់តម្លៃដែលបានបញ្ចូលដោយអ្នកប្រើប្រាស់ជាលេខ។

នោះគឺរង្វិលជុំនឹងត្រូវបានប្រតិបត្តិជាទៀងទាត់រហូតដល់លក្ខខណ្ឌកើតឡើង។ ក្នុងស្ថានភាពនេះវាដំណើរការដូចនេះ។ 

នោះ​គឺ​អ្នក​អាច​ទៅ​ពី​ចំណុច​ផ្ទុយ​គ្នា​: ធ្វើ​ការ​រង្វិលជុំ​សកម្មភាព​ជាក់លាក់​មួយ​រហូត​ដល់​ព្រឹត្តិការណ៍​ក្លាយ​ទៅ​ជា​មិន​ពិត​។

ការញែកកូដ

ឥឡូវ​យើង​មើល​លម្អិត​បន្ថែម​ទៀត​ពី​របៀប​ដែល​កូដ​នេះ​ដំណើរការ។ ដើម្បីធ្វើដូចនេះយើងនឹងវិភាគវាមួយជំហានម្តង ៗ ។

1. ដំបូង អ្នកប្រើប្រាស់បញ្ចូលខ្សែអក្សរ ដែលត្រូវបានទទួលយកដោយ variable n ។ 
2. ដោយប្រើរង្វិលជុំ ខណៈពេល ប្រភេទនៃអថេរនេះត្រូវបានពិនិត្យ។ នៅលើធាតុដំបូងវាមិនស្មើគ្នាទេ។ int. ដូច្នេះ​ហើយ​ជា​លទ្ធផល​នៃ​ការ​ធ្វើ​តេស្ត​រក​ឃើញ​ថា​លក្ខខណ្ឌ​នេះ​ពិត។ ដូច្នេះតួរង្វិលជុំត្រូវបានបញ្ចូល។
3. ដោយមានជំនួយពីប្រតិបត្តិករ ព្យាយាម យើងកំពុងព្យាយាមបំប្លែងខ្សែអក្សរទៅជាលេខ។ ប្រសិនបើនេះត្រូវបានធ្វើ, នោះគ្មានកំហុសកើតឡើង។ ដូច្នោះហើយមិនចាំបាច់ដំណើរការវាទេ។ ដូច្នេះអ្នកបកប្រែត្រឡប់ទៅការចាប់ផ្តើមនៃរង្វិលជុំវិញហើយយោងទៅតាមលទ្ធផលនៃការពិនិត្យវាប្រែថាវាបានក្លាយទៅជាចំនួនគត់។ ដូច្នេះសូមទៅជំហានទី 7
4. ប្រសិន​បើ​ការ​បម្លែង​មិន​បាន​ជោគជ័យ នោះ ValueError ត្រូវ​បាន​បោះចោល។ ក្នុងករណីនេះលំហូរកម្មវិធីត្រូវបានផ្ញើទៅអ្នកដោះស្រាយលើកលែងតែ។
5. អ្នកប្រើប្រាស់បញ្ចូលតម្លៃថ្មីដែលត្រូវបានកំណត់ទៅអថេរ n ។
6. អ្នកបកប្រែត្រឡប់ទៅជំហានទី 2 ហើយពិនិត្យម្តងទៀត។ ប្រសិនបើវាជាតម្លៃចំនួនគត់ សូមចូលទៅកាន់ជំហានទី 7។ ប្រសិនបើមិនមែនទេ ការបម្លែងត្រូវបានព្យាយាមម្តងទៀតដោយយោងតាមជំហានទី 3 ។
7. ដោយមានជំនួយពីប្រតិបត្តិករ if កំណត់ថាតើមាននៅសល់បន្ទាប់ពីចែកលេខដោយ 2 ។ 
8. បើ​មិន​ដូច្នោះ​ទេ អត្ថបទ "សូម្បី" ត្រូវ​បាន​ត្រឡប់​មក​វិញ។
9. បើមិនដូច្នោះទេ អត្ថបទ "សេស" នឹងត្រលប់មកវិញ។

ឥឡូវនេះ សូមពិចារណាឧទាហរណ៍បែបនេះ។ ព្យាយាមកំណត់ថាតើវដ្តនេះនឹងឆ្លងកាត់ប៉ុន្មានដង?

សរុប = 100 

i = 0 ។

ខណៈពេលដែលខ្ញុំ <5:

    n = int(បញ្ចូល())

    សរុប = សរុប — ន

    i = ខ្ញុំ + 1 

បោះពុម្ព ("នៅសល់", សរុប)

ចំលើយដែលត្រឹមត្រូវគឺ 5. ដំបូងតម្លៃនៃអថេរ i - សូន្យ។ អ្នកបកប្រែពិនិត្យមើលថាតើអថេរស្មើគ្នាឬអត់ i 4 ឬតិចជាងនេះ។ ប្រសិនបើបាទ/ចាស នោះតម្លៃនឹងត្រលប់មកវិញ។ ជាការពិតហើយរង្វិលជុំត្រូវបានប្រតិបត្តិតាម។ តម្លៃត្រូវបានកើនឡើងដោយមួយ។

បន្ទាប់ពីការធ្វើម្តងទៀតលើកដំបូង តម្លៃនៃអថេរក្លាយជា 1។ ការត្រួតពិនិត្យមួយត្រូវបានអនុវត្ត ហើយកម្មវិធីយល់ថាចំនួននេះម្តងទៀតតិចជាង 5។ ដូច្នេះហើយ តួរង្វិលជុំត្រូវបានប្រតិបត្តិជាលើកទីពីរ។ ដោយសារជំហានគឺស្រដៀងគ្នា តម្លៃក៏កើនឡើងដោយមួយ ហើយអថេរឥឡូវនេះស្មើនឹង 2 ។

តម្លៃនេះក៏តិចជាងប្រាំដែរ។ បន្ទាប់មករង្វិលជុំត្រូវបានប្រតិបត្តិជាលើកទីបី បន្ថែមទៅអថេរ i 1 ហើយ​វា​ត្រូវ​បាន​កំណត់​តម្លៃ 3. ម្ដង​ទៀត​គឺ​តិច​ជាង​ប្រាំ។ ដូច្នេះហើយ វាមកដល់ការបញ្ជូលទីប្រាំមួយនៃរង្វិលជុំ ដែលតម្លៃនៃអថេរ i ស្មើនឹង 5 (បន្ទាប់ពីទាំងអស់ វាជាសូន្យពីដំបូង តាមដែលយើងចងចាំ)។ ដូច្នោះហើយលក្ខខណ្ឌនេះមិនឆ្លងកាត់ការសាកល្បងទេហើយរង្វិលជុំត្រូវបានបញ្ចប់ដោយស្វ័យប្រវត្តិហើយការផ្លាស់ប្តូរទៅជំហានបន្ទាប់ដែលនៅខាងក្រៅវា (ឬការបញ្ចប់កម្មវិធីប្រសិនបើជំហានខាងក្រោមមិនត្រូវបានផ្តល់ឱ្យ) ត្រូវបានអនុវត្ត។

វដ្តក៏អាចកើតឡើងក្នុងទិសដៅផ្ទុយ។ នេះគឺជាឧទាហរណ៍នៃកូដដែលជាមួយនឹងការធ្វើឡើងវិញជាបន្តបន្ទាប់នីមួយៗ មួយត្រូវបានដកចេញពីតម្លៃបច្ចុប្បន្ននៃអថេរ។ 

សរុប = 100 

ខណៈពេលដែលសរុប > 0:

    n = int(បញ្ចូល())

    សរុប = សរុប — ន 

បោះពុម្ព ("ធនធានអស់ហើយ")

សាកទាយមើលថាកម្មវិធីនេះធ្វើអ្វី! ស្រមៃថានៅក្នុងអថេរមួយ។ ចំនួនសរុប ព័ត៌មានអំពីធនធានកម្មវិធីត្រូវបានរក្សាទុក។ រាល់ពេលដែលអ្នកបកប្រែពិនិត្យមើលថាតើធនធានមានឬអត់។ បើមិនដូច្នោះទេ អត្ថបទ "ធនធានអស់ហើយ" ត្រូវបានបង្ហាញ ហើយកម្មវិធីនឹងបិទ។ ហើយជាមួយនឹងការធ្វើម្តងទៀតនៃរង្វិលជុំនីមួយៗ ធនធានថយចុះដោយចំនួនដែលអ្នកប្រើប្រាស់បញ្ជាក់។

ហើយឥឡូវនេះកិច្ចការផ្ទះ។ សាកល្បងផ្លាស់ប្តូរកូដខាងលើ ដើម្បីកុំឱ្យអថេរមិនអាចក្លាយជាអវិជ្ជមានបានទេ។