នៅក្នុងកម្មវិធី, វដ្តo while គឺជារចនាសម្ព័ន្ធគ្រប់គ្រងដែលអនុញ្ញាតឱ្យប្លុកកូដត្រូវបានប្រតិបត្តិម្តងហើយម្តងទៀតដរាបណាលក្ខខណ្ឌជាក់លាក់មួយត្រូវបានបំពេញ។ នៅក្នុង Python, while loop គឺជាឧបករណ៍ដ៏មានឥទ្ធិពល និងអាចបត់បែនបាន ដែលអនុញ្ញាតឱ្យយើងធ្វើស្វ័យប្រវត្តិកម្មដំណើរការ និងបំពេញការងារដដែលៗ។ តាមរបៀបដ៏មានប្រសិទ្ធភាព. នៅក្នុងអត្ថបទនេះ យើងនឹងស្វែងយល់លម្អិតអំពីអ្វីដែល while loop នៅក្នុង Python របៀបដែលវាដំណើរការ និងរបៀបដែលយើងអាចប្រើប្រាស់វាបានច្រើនបំផុតនៅក្នុងកម្មវិធីរបស់យើង។
El ខណៈពេលដែលរង្វិលជុំ នៅក្នុង Python វាគឺជារចនាសម្ព័ន្ធគ្រប់គ្រងដែលប្រើដើម្បីធ្វើឡើងវិញនូវលំដាប់នៃ statement ដរាបណាលក្ខខណ្ឌមួយគឺពិត មិនដូចសម្រាប់ loop ទេ while loop មិនតម្រូវឱ្យមានជួរដែលបានកំណត់ជាមុនទេព្រោះវាដំណើរការរហូតដល់លក្ខខណ្ឌដែលបានបញ្ជាក់មិនពិត។ នេះអនុញ្ញាតឱ្យប្រើ while loop ក្នុងស្ថានភាពដែលវាមិនត្រូវបានគេដឹងជាមុនថាតើប្លុកកូដនឹងត្រូវធ្វើម្តងទៀតប៉ុន្មានដង។
លក្ខខណ្ឌនិងកូដប្លុក: while loop រួមមាន a លក្ខខណ្ឌ និង ក ប្លុកកូដ. លក្ខខណ្ឌគឺជាកន្សោម Boolean ដែលត្រូវបានវាយតម្លៃមុនពេលធ្វើម្តងទៀតនីមួយៗ ប្រសិនបើលក្ខខណ្ឌគឺពិត ប្លុកកូដត្រូវបានប្រតិបត្តិ បើមិនដូច្នេះទេ រង្វិលជុំត្រូវបានចាកចេញ។ វាជាការសំខាន់ក្នុងការកត់សម្គាល់ថាប្រសិនបើលក្ខខណ្ឌដំបូងមិនពិតនោះប្លុកកូដនឹងមិនត្រូវបានប្រតិបត្តិទាល់តែសោះ។
ជៀសវាងរង្វិលជុំគ្មានកំណត់៖ ចំណុចសំខាន់បំផុតមួយដែលត្រូវពិចារណានៅពេលប្រើ while loop គឺត្រូវប្រាកដថាលក្ខខណ្ឌក្លាយជាមិនពិតនៅចំណុចណាមួយ។ បើមិនដូច្នោះទេ ក រង្វិលជុំគ្មានកំណត់ ហើយកម្មវិធីនឹងជាប់នៅក្នុងពាក្យដដែលៗជាបន្តបន្ទាប់ ដែលនាំទៅដល់ការគាំង ឬដំណើរការដោយមិនមានការរំខាន។ វាចាំបាច់ក្នុងការរចនាប្លុកកូដតាមរបៀបដែលលក្ខខណ្ឌអាចផ្លាស់ប្តូរហើយនៅទីបំផុតក្លាយជាមិនពិតដើម្បីបញ្ចប់រង្វិលជុំលើសពីនេះទៀតវាអាចប្រើសេចក្តីថ្លែងការណ៍ដូចជា បំបែក ដើម្បីបង្ខំ ការចេញនៃរង្វិលជុំ ប្រសិនបើលក្ខខណ្ឌជាក់លាក់មួយចំនួនត្រូវបានបំពេញក្នុងពេលប្រតិបត្តិ។
វដ្ដ ខណៈពេល នៅក្នុង Python វាគឺជារចនាសម្ព័ន្ធគ្រប់គ្រងដែលអនុញ្ញាតឱ្យកូដត្រូវបានប្រតិបត្តិម្តងហើយម្តងទៀតដរាបណាលក្ខខណ្ឌជាក់លាក់មួយត្រូវបានបំពេញ។ មិនដូចវដ្ត សម្រាប់while loop មិនមានចំនួនថេរនៃការធ្វើដដែលៗទេ ព្រោះវានឹងត្រូវបានប្រតិបត្តិគ្រប់ពេលដែលលក្ខខណ្ឌពិត។ នេះផ្តល់នូវភាពបត់បែនដ៏អស្ចារ្យនៅក្នុងស្ថានភាពដែលចំនួននៃការធ្វើឡើងវិញមិនត្រូវបានកំណត់ជាមុន។
វាក្យសម្ព័ន្ធមូលដ្ឋាននៃ while loop នៅក្នុង Python មានដូចខាងក្រោម៖
«`ពស់ថ្លាន់
ខណៈពេលដែល
« `
ក្នុងករណីនេះ ប្លុកនៃកូដដែលមានរវាងចំនុចទាំងពីរ (:) នឹងត្រូវបានប្រតិបត្តិម្តងហើយម្តងទៀត ដរាបណាលក្ខខណ្ឌដែលបានបញ្ជាក់គឺពិត។ វាជាការសំខាន់ដែលត្រូវចងចាំថា ប្រសិនបើលក្ខខណ្ឌមិនត្រូវបានបំពេញទេ រង្វិលជុំខណៈពេលដែលនឹងក្លាយទៅជារង្វិលជុំគ្មានកំណត់ ហើយនឹងត្រូវបានប្រតិបត្តិជាបន្តបន្ទាប់។ ដូច្នេះ ត្រូវប្រាកដថារួមបញ្ចូលតក្កវិជ្ជាដែលអនុញ្ញាតឱ្យអ្នកចេញពីរង្វិលជុំនៅចំណុចមួយចំនួន ដូចជាការកែប្រែ លក្ខខណ្ឌ ឬការប្រើសេចក្តីថ្លែងការណ៍។ បំបែក.
គុណសម្បត្តិមួយក្នុងចំណោមគុណសម្បត្តិនៃ while loop គឺថាវាអនុញ្ញាតឱ្យអ្នកអនុវត្តការបន្តសុពលភាព និងបន្តការប្រតិបត្តិកូដរហូតដល់លក្ខខណ្ឌជាក់លាក់មួយត្រូវបានបំពេញ។ វាមានប្រយោជន៍ជាពិសេសនៅពេលដែលយើងមិនដឹងជាមុនអំពីចំនួនដងដែលកូដគួរតែត្រូវបានប្រតិបត្តិ។ វាក៏អាចត្រូវបានផ្សំជាមួយធាតុគ្រប់គ្រងលំហូរផ្សេងទៀត ដូចជាលក្ខខណ្ឌ និងមុខងារ។ ដើម្បីបង្កើត។ កម្មវិធីកាន់តែស្មុគស្មាញ និងពេញលេញ។ សរុបមក while loop នៅក្នុង Python គឺជាឧបករណ៍ដ៏មានអានុភាពដែលអនុញ្ញាតឱ្យយើងធ្វើកូដដដែលៗ ដរាបណាលក្ខខណ្ឌដែលបានផ្តល់ឱ្យត្រូវបានបំពេញ ដោយផ្តល់នូវភាពបត់បែន និងការគ្រប់គ្រងនៅក្នុងកម្មវិធីរបស់យើង។
- 1. វាក្យសម្ព័ន្ធមូលដ្ឋាន៖
វដ្ត ខណៈពេល នៅក្នុង Python វាត្រូវបានប្រើដើម្បីធ្វើប្លុកកូដឡើងវិញដរាបណាលក្ខខណ្ឌជាក់លាក់មួយគឺពិត។ វាក្យសម្ព័ន្ធរង្វិលជុំមូលដ្ឋាន ខណៈពេល មានដូចខាងក្រោម៖
while condición:
código a ejecutar
លក្ខខណ្ឌគឺជាកន្សោមប៊ូលីនដែលត្រូវបានវាយតម្លៃមុនការធ្វើឡើងវិញនីមួយៗនៃរង្វិលជុំ។ ប្រសិនបើលក្ខខណ្ឌគឺពិត ប្លុកកូដត្រូវបានប្រតិបត្តិ។ បន្ទាប់ពីការធ្វើម្តងទៀត លក្ខខណ្ឌត្រូវបានវាយតម្លៃឡើងវិញ។ ប្រសិនបើលក្ខខណ្ឌនៅតែជាការពិត នោះវដ្តនឹងកើតឡើងម្តងទៀត។ ប្រសិនបើលក្ខខណ្ឌមិនពិត រង្វិលជុំ ខណៈពេល ឈប់ ហើយការប្រតិបត្តិកម្មវិធីបន្តជាមួយការណែនាំបន្ទាប់បន្ទាប់ពីរង្វិលជុំ។
- 2. រចនាសម្ព័ន្ធ និងលំហូរនៃរង្វិលជុំខណៈពេលមួយ៖
នៅក្នុងវដ្តមួយ។ ខណៈពេលវាជារឿងសំខាន់ដើម្បីធានាថាស្ថានភាពនៅក្នុងរង្វិលជុំត្រូវបានធ្វើបច្ចុប្បន្នភាពយ៉ាងត្រឹមត្រូវក្នុងអំឡុងពេលប្រតិបត្តិ។ ប្រសិនបើលក្ខខណ្ឌមិនក្លាយជាមិនពិត រង្វិលជុំនឹងដំណើរការដោយគ្មានកំណត់ ដែលអាចបណ្តាលឱ្យ an error នៅក្នុងកម្មវិធី។ ដូច្នេះ វាជារឿងធម្មតាទេក្នុងការប្រើអថេរជាអ្នករាប់ ហើយធ្វើបច្ចុប្បន្នភាពវានៅក្នុងរង្វិលជុំ ដើម្បីគ្រប់គ្រងលក្ខខណ្ឌនៃការបំពេញ។
នេះគឺជាឧទាហរណ៍ សាមញ្ញមួយ ដើម្បីបង្ហាញពីរបៀបដែលលំហូរនៃវដ្ត ដំណើរការ ខណៈពេល:
n = 1
while n <= 5:
print("Iteración", n)
n += 1
ក្នុងឧទាហរណ៍នេះ អថេរត្រូវបានចាប់ផ្តើម n ជាមួយនឹងតម្លៃ 1 ហើយលក្ខខណ្ឌត្រូវបានបង្កើតឡើងដែលវដ្តត្រូវបានធ្វើម្តងទៀតខណៈពេលដែល n តិចជាង ឬ ស្មើ 5. ក្នុង ម្តងមួយៗ លេខ ឡើងវិញ គឺ បោះពុម្ព និង តម្លៃ នៃ n ក្នុងមួយ។ រង្វិលជុំនឹងត្រូវបានប្រតិបត្តិប្រាំដងដោយបង្កើតលទ្ធផលដូចខាងក្រោម:
Iteración 1
Iteración 2
Iteración 3
Iteración 4
Iteración 5
- 3. ការគ្រប់គ្រងលំហូរនៅក្នុងរង្វិលជុំខណៈពេលមួយ:
នៅក្នុង Python វាអាចគ្រប់គ្រងលំហូរនៃរង្វិលជុំ ខណៈពេល ដោយប្រើសេចក្តីថ្លែងការណ៍ បំបែក y បន្ត. សេចក្តីថ្លែងការណ៍ បំបែក អនុញ្ញាតឱ្យអ្នកចេញពីរង្វិលជុំភ្លាមៗ ដោយមិនគិតពីថាតើលក្ខខណ្ឌនៅតែត្រូវតាមនោះទេ។ ម្យ៉ាងវិញទៀត សេចក្តីថ្លែងការណ៍ បន្ត លោតទៅ iteration បន្ទាប់នៃរង្វិលជុំដោយមិនអើពើនឹងលេខកូដណាមួយដែលនៅសេសសល់ដើម្បីប្រតិបត្តិក្នុងការធ្វើម្តងទៀតនោះ។
សេចក្តីថ្លែងការណ៍ទាំងនេះមានប្រយោជន៍នៅពេលដែលអ្នកត្រូវការរំខាន a វដ្តមុនពេលកំណត់ ឬរំលងការបន្តមួយចំនួនដោយផ្អែកលើលក្ខខណ្ឌមួយ។ ទោះជាយ៉ាងណាក៏ដោយ វាជារឿងសំខាន់ក្នុងការប្រើប្រាស់ពួកវាដោយប្រុងប្រយ័ត្ន ព្រោះការប្រើប្រាស់មិនត្រឹមត្រូវអាចនាំទៅរកលទ្ធផលដែលមិនរំពឹងទុក ឬវដ្តគ្មានទីបញ្ចប់។
ជាមួយនឹងចំណេះដឹងអំពីវាក្យសម្ព័ន្ធនិងរចនាសម្ព័ន្ធនៃវដ្ត ខណៈពេល នៅក្នុង Python អ្នកអាចបង្កើតរង្វិលជុំដែលមានអនុភាព និងអាចបត់បែនបាន ដែលនឹងអនុញ្ញាតឱ្យអ្នកធ្វើកូដឡើងវិញបានច្រើនដងតាមដែលចាំបាច់ ដរាបណាលក្ខខណ្ឌជាក់លាក់មួយត្រូវបានបំពេញ។
វដ្ដ ខណៈពេល គឺជារចនាសម្ព័ន្ធគ្រប់គ្រងដែលប្រើក្នុង Python ដើម្បីធ្វើប្លុកកូដឡើងវិញដរាបណាសំណើត្រូវបានបំពេញ។ លក្ខខណ្ឌ កំណត់។ នៅពេលអ្នកបកប្រែភាសា Python ជួបប្រទះរង្វិលជុំ ខណៈពេល នៅក្នុងកម្មវិធី វាវាយតម្លៃលក្ខខណ្ឌដែលភ្ជាប់ជាមួយវា។ ប្រសិនបើលក្ខខណ្ឌគឺពិត ប្លុកកូដនៅក្នុងរង្វិលជុំត្រូវបានប្រតិបត្តិ។ នៅពេលដែលការប្រតិបត្តិប្លុកត្រូវបានបញ្ចប់ លក្ខខណ្ឌត្រូវបានវាយតម្លៃម្តងទៀត។ ដំណើរការនេះ វាត្រូវបានធ្វើម្តងទៀតរហូតដល់លក្ខខណ្ឌក្លាយជាមិនពិត។
នេះ។ លក្ខខណ្ឌ នៃវដ្ត ខណៈពេល អាចជាកន្សោម ឬអថេរណាមួយដែលទទួលបានតម្លៃការពិត ជាការពិត ទាំង មិនពិត. លក្ខខណ្ឌត្រូវបានវាយតម្លៃមុនពេលប្លុកកូដត្រូវបានប្រតិបត្តិ ដែលមានន័យថាប្រសិនបើលក្ខខណ្ឌមិនពិត តាំងពីដំបូងប្លុកកូដនឹងមិនត្រូវបានប្រតិបត្តិទាល់តែសោះ។ វាមានសារៈសំខាន់ណាស់ក្នុងការប្រុងប្រយ័ត្ននៅពេលកំណត់លក្ខខណ្ឌដើម្បីជៀសវាងការធ្លាក់ចូលទៅក្នុងរង្វិលជុំគ្មានកំណត់។
ក្នុងអំឡុងពេលនៃការប្រតិបត្តិនៃវដ្តមួយ។ ខណៈពេល, វាអាចទៅរួច កែប្រែ តម្លៃនៃអថេរ ឬកន្សោមដែលប្រើក្នុងលក្ខខណ្ឌ។ នេះអាចអនុញ្ញាតឱ្យអ្នកគ្រប់គ្រងលំហូរនៃកម្មវិធី និងគ្រប់គ្រងនៅពេលដែលត្រូវចេញពីរង្វិលជុំ។ វាជារឿងធម្មតាទេក្នុងការប្រើ control constructors ជាការប្រកាស។ បំបែក ឬ បន្ត នៅខាងក្នុងប្លុកកូដ cycle ខណៈពេល ដើម្បីបញ្ឈប់ការប្រតិបត្តិ ឬលោតទៅការបន្តបន្ទាប់ក្រោមលក្ខខណ្ឌជាក់លាក់។
- ដំណើរការកិច្ចការម្តងហើយម្តងទៀត៖ while loop នៅក្នុង Python ត្រូវបានប្រើដើម្បីប្រតិបត្តិប្លុកនៃកូដដដែលៗ ដរាបណាលក្ខខណ្ឌជាក់លាក់មួយនៅតែជាការពិត។ វាមានប្រយោជន៍ជាពិសេសនៅពេលដែលយើងត្រូវបំពេញកិច្ចការមួយដងច្រើនដង ដោយមិនដឹងថាប៉ុន្មានដងពិតប្រាកដ។ ឧទាហរណ៍ យើងអាចប្រើពេលមួយរង្វិលជុំដើម្បីបោះពុម្ពលេខ 1 ដល់ 10 ទៅកុងសូល។
- អន្តរកម្មជាមួយអ្នកប្រើប្រាស់៖ ការប្រើប្រាស់ទូទៅមួយទៀតនៃ while loop គឺអន្តរកម្មជាមួយអ្នកប្រើប្រាស់ ដោយប្រើមុខងារ បញ្ចូល()យើងអាចស្នើឱ្យអ្នកប្រើបញ្ចូលតម្លៃមួយ ហើយប្រើរង្វិលជុំមួយដើម្បីបន្តស្នើសុំការបញ្ចូលរហូតដល់ អនុញ្ញាតឱ្យវាត្រូវបានបំពេញ លក្ខខណ្ឌជាក់លាក់មួយ។ ឧទាហរណ៍ យើងអាចសុំឱ្យអ្នកប្រើប្រាស់ទាយលេខមួយ ហើយប្រើ while loop ដើម្បីប្រាប់អ្នកប្រើប្រាស់ឱ្យបញ្ចូលម្តងហើយម្តងទៀត រហូតដល់អ្នកប្រើប្រាស់ទាយលេខត្រឹមត្រូវ។
- សុពលភាពទិន្នន័យ៖ while loop ក៏មានប្រយោជន៍សម្រាប់ផ្ទៀងផ្ទាត់ទិន្នន័យដែលបានបញ្ចូលដោយអ្នកប្រើប្រាស់ផងដែរ។ យើងអាចប្រើពេលមួយរយៈដើម្បីស្នើសុំការបញ្ចូលពីអ្នកប្រើ ហើយពិនិត្យមើលថាតើវាត្រូវនឹងលក្ខខណ្ឌជាក់លាក់ឬអត់។ ប្រសិនបើលក្ខខណ្ឌមិនត្រូវបានបំពេញ យើងអាចស្នើសុំការបញ្ចូលម្តងទៀតរហូតដល់អ្នកប្រើប្រាស់ផ្តល់តម្លៃត្រឹមត្រូវ។ បច្ចេកទេសនេះមានប្រយោជន៍ជាពិសេសនៅពេលដែលការបញ្ចូលជាក់លាក់ ឬទម្រង់ជាក់លាក់ណាមួយត្រូវបានរំពឹងទុក។
while loop គឺជារចនាសម្ព័ន្ធគ្រប់គ្រងដែលអនុញ្ញាតឱ្យប្លុកកូដត្រូវបានធ្វើម្តងទៀតនៅក្នុង Python ដរាបណាលក្ខខណ្ឌជាក់លាក់មួយត្រូវបានបំពេញ។ វាមានសារៈប្រយោជន៍ណាស់នៅពេលដែលអ្នកត្រូវការប្រតិបត្តិកិច្ចការម្តងហើយម្តងទៀតរហូតដល់លក្ខខណ្ឌជាក់លាក់ណាមួយត្រូវបានបំពេញ។ ទោះជាយ៉ាងណាក៏ដោយ វាជារឿងសំខាន់ក្នុងការចងចាំការពិចារណាសំខាន់ៗមួយចំនួន ដើម្បីប្រើប្រាស់ while loop ប្រកបដោយប្រសិទ្ធភាព។
1. កំណត់លក្ខខណ្ឌចាកចេញឱ្យបានត្រឹមត្រូវ៖ មុនពេល ប្រើប្រាស់ while loop វាចាំបាច់ណាស់ក្នុងការកំណត់លក្ខខណ្ឌឱ្យបានត្រឹមត្រូវដែលនឹងកំណត់នៅពេលដែល រង្វិលជុំ គួរតែត្រូវបានចាកចេញ។ ប្រសិនបើលក្ខខណ្ឌមិនត្រូវបានបំពេញដំបូង នោះរង្វិលជុំនឹងមិនត្រូវបានអនុវត្តទេ។ ម្យ៉ាងវិញទៀត ប្រសិនបើលក្ខខណ្ឌត្រូវបានបំពេញជានិច្ច នោះរង្វិលជុំនឹងក្លាយទៅជារង្វិលជុំគ្មានកំណត់ ដែលអាចបណ្តាលឱ្យមានការប្រើប្រាស់ធនធានច្រើនពេក និងគាំងកម្មវិធី។
2. ធ្វើបច្ចុប្បន្នភាពអថេរគ្រប់គ្រង៖ នៅក្នុង while loop វាចាំបាច់ដើម្បីធ្វើបច្ចុប្បន្នភាពអថេរដែលគ្រប់គ្រងលក្ខខណ្ឌអថេរនេះត្រូវតែផ្លាស់ប្តូរតម្លៃរបស់វាក្នុងការធ្វើម្តងទៀតនីមួយៗដើម្បីធានាថានៅចំណុចណាមួយលក្ខខណ្ឌមិនត្រូវបានបំពេញហើយរង្វិលជុំត្រូវបានចាកចេញ។ ការភ្លេចធ្វើបច្ចុប្បន្នភាពអថេរវត្ថុបញ្ជាអាចនាំឱ្យមានរង្វិលជុំគ្មានកំណត់ ឬរង្វិលជុំមិនដំណើរការដូចការរំពឹងទុក។
3. ជៀសវាងបញ្ហាតក្កវិជ្ជា៖ វាមានសារៈសំខាន់ណាស់ក្នុងការត្រួតពិនិត្យមើលដោយប្រុងប្រយ័ត្ននូវតក្កវិជ្ជានៃកូដនៅក្នុងរង្វង់ដើម្បីជៀសវាងកំហុស និងលទ្ធផលដែលមិនរំពឹងទុក។ ប្រសិនបើតក្កវិជ្ជាមិនត្រូវបានគ្រោងទុកល្អទេ វាអាចទៅរួចដែលថាវដ្តនេះត្រូវបានប្រតិបត្តិច្រើនជាងការចាំបាច់ ឬលទ្ធផលដែលចង់បានមិនត្រូវបានសម្រេច។ លើសពីនេះ គួរតែរួមបញ្ចូលការណែនាំអំពីការចេញដំណើរមុនគេ ដោយប្រើសេចក្តីថ្លែងការណ៍ break នៅពេលចាំបាច់ ដើម្បីរំខានវដ្ត មុនពេលលក្ខខណ្ឌដែលបានបង្កើតឡើងដំបូងត្រូវបានបំពេញ។
while loop គឺជារចនាសម្ព័ន្ធគ្រប់គ្រង នៅក្នុង Python ដែលត្រូវបានប្រើ ដើម្បីបន្តធ្វើម្តងទៀតប្លុកនៃកូដ ខណៈពេល លក្ខខណ្ឌជាក់លាក់មួយត្រូវបានបំពេញ។ វាអាចមានប្រយោជន៍ខ្លាំងណាស់នៅពេលដែលអ្នកត្រូវការប្រតិបត្តិសកម្មភាពម្តងហើយម្តងទៀតរហូតដល់លក្ខខណ្ឌជាក់លាក់មួយត្រូវបានបំពេញ វដ្តគ្មានកំណត់ ដែលមិនឈប់ឈរ។
ដើម្បី ជៀសវាងរង្វិលជុំគ្មានកំណត់ នៅក្នុង while loop វាចាំបាច់ណាស់ក្នុងការធានាថាលក្ខខណ្ឌចេញត្រូវបានបំពេញនៅចំណុចណាមួយ។ នេះត្រូវបានសម្រេចដោយការកែប្រែលក្ខខណ្ឌត្រួតពិនិត្យនៅក្នុងរង្វិលជុំ ឬដោយប្រើរចនាសម្ព័ន្ធវត្ថុបញ្ជាបន្ថែមដូចជា a បំបែក។ នេះ បំបែក អនុញ្ញាតឱ្យអ្នកចេញពី while loop ភ្លាមៗ នៅពេលដែលលក្ខខណ្ឌជាក់លាក់មួយត្រូវបានបំពេញ ដូច្នេះជៀសវាងការដដែលៗគ្មានកំណត់។
វិធីមួយទៀតដើម្បីជៀសវាងរង្វិលជុំគ្មានកំណត់នៅក្នុង while loop គឺត្រូវប្រើ a counter variable ដែល កើនឡើងក្នុងការធ្វើម្តងទៀតនៃវដ្ត។ អថេរនេះអាចត្រូវបានប្រើជាលក្ខខណ្ឌចេញ ដូច្នេះខណៈពេលដែលរង្វិលជុំឈប់នៅពេលអថេរបានឈានដល់តម្លៃអតិបរមាដែលកំណត់ជាមុនជាក់លាក់។ វាជាការសំខាន់ក្នុងការកត់សម្គាល់ថាអថេររាប់ត្រូវតែត្រូវបានធ្វើបច្ចុប្បន្នភាពឱ្យបានត្រឹមត្រូវនៅក្នុងរង្វិលជុំដើម្បីជៀសវាងការកើតឡើងដដែលៗដែលមិនចាំបាច់ឬលក្ខខណ្ឌចាកចេញដែលមិនអាចទៅដល់បាន។
វដ្ដ ខណៈពេល វាគឺជារចនាសម្ព័ន្ធគ្រប់គ្រងដែលប្រើច្រើនបំផុតមួយនៅក្នុង Python វាអនុញ្ញាតឱ្យប្លុកកូដត្រូវបានប្រតិបត្តិម្តងហើយម្តងទៀតដរាបណាលក្ខខណ្ឌដែលបានកំណត់គឺពិត។ រចនាសម្ព័ន្ធនេះគឺល្អនៅពេលដែលចំនួននៃការធ្វើម្តងទៀតមិនត្រូវបានគេដឹងជាមុន។
ខាងក្រោមនេះជាមួយចំនួន អនុសាសន៍ ដើម្បីកែលម្អការអនុវត្តនៃ while loop នៅក្នុង Python៖
1. ការធ្វើឱ្យប្រសើរលក្ខខណ្ឌ: លក្ខខណ្ឌដែលត្រូវបានវាយតម្លៃនៅក្នុង while loop អាចជាកត្តាកំណត់ក្នុងដំណើរការ។ វាមានសារៈសំខាន់ណាស់ក្នុងការធានាថាលក្ខខណ្ឌគឺសាមញ្ញ និងមានប្រសិទ្ធភាពតាមដែលអាចធ្វើទៅបាន។ ការជៀសវាងប្រតិបត្តិការដែលមិនចាំបាច់ ឬស្មុគស្មាញអាចសន្សំសំចៃពេលវេលាប្រតិបត្តិ។
2. ការប្រើប្រាស់ត្រឹមត្រូវនៃអថេរ៖ អថេរដែលប្រើក្នុងលក្ខខណ្ឌ while loop ត្រូវតែត្រូវបានធ្វើបច្ចុប្បន្នភាពយ៉ាងត្រឹមត្រូវក្នុងប្លុកកូដ។ វាចាំបាច់ណាស់ដែលអថេរផ្លាស់ប្តូរតម្លៃរបស់វាឱ្យបានត្រឹមត្រូវ បើមិនដូច្នេះទេ រង្វិលជុំអាចក្លាយជាគ្មានកំណត់ ឬត្រូវបានប្រតិបត្តិច្រើនជាងការចាំបាច់។
១. ជៀសវាងប្រតិបត្តិការថ្លៃដើមក្នុងវដ្ត៖ ប្រសិនបើមានប្រតិបត្តិការដែលត្រូវការពេលវេលាដំណើរការច្រើនដូចជាការគណនាគណិតវិទ្យាស្មុគស្មាញ ឬការចូលប្រើមូលដ្ឋានទិន្នន័យ វាជាការប្រសើរក្នុងការអនុវត្តប្រតិបត្តិការទាំងនេះនៅក្រៅ while loop ។ នៅក្នុងវិធីនេះ អ្នកជៀសវាងការធ្វើប្រតិបត្តិការទាំងនេះឡើងវិញដោយមិនចាំបាច់ក្នុងការធ្វើម្តងទៀតនីមួយៗ ដែលនឹងធ្វើឱ្យដំណើរការនៃវដ្តនេះប្រសើរឡើង។
វដ្ដ ខណៈពេល គឺជារចនាសម្ព័ន្ធគ្រប់គ្រងនៅក្នុង Python ដែលត្រូវបានប្រើដើម្បីធ្វើឡើងវិញនូវប្លុកនៃកូដខណៈពេលដែលលក្ខខណ្ឌដែលបានបញ្ជាក់ត្រូវបានបំពេញ។ Aមិនដូចវត្ថុបញ្ជាផ្សេងទៀតរចនាសម្ព័ន្ធដូចជា សម្រាប់ o ធ្វើ - ខណៈពេល, វដ្ត ខណៈពេល វាត្រូវបានប្រតិបត្តិនៅពេលណាដែលលក្ខខណ្ឌគឺពិត ដោយមិនដឹងជាមុនអំពីចំនួនពិតប្រាកដនៃការធ្វើម្តងទៀតដែលនឹងត្រូវបានអនុវត្ត។
មួយនៃភាពខុសគ្នាសំខាន់រវាងវដ្ត ខណៈពេល និងរចនាសម្ព័ន្ធគ្រប់គ្រងផ្សេងទៀតគឺថាលក្ខខណ្ឌត្រូវបានវាយតម្លៃនៅដើមដំបូងនៃការធ្វើឡើងវិញនីមួយៗ។ ប្រសិនបើលក្ខខណ្ឌគឺ ពិត, ប្លុកកូដនៅក្នុង ខណៈពេល ត្រូវបានប្រតិបត្តិ; បើមិនដូច្នេះទេ ប្លុកត្រូវបានរំលង ហើយការប្រតិបត្តិបន្តជាមួយនឹងកូដបន្ទាប់បន្ទាប់ ខណៈពេល. នេះមានន័យថា ប្រសិនបើលក្ខខណ្ឌមិនត្រូវបានបំពេញទេនោះ ប្លុកកូដនៅក្នុង ខណៈពេល នឹងមិនដែលត្រូវបានប្រតិបត្តិឡើយ។
ភាពខុសគ្នាសំខាន់មួយទៀតគឺថាវដ្ត ខណៈពេល អ្នកអាចមានលក្ខខណ្ឌដែលពាក់ព័ន្ធនឹងអថេរច្រើន និងប្រតិបត្តិករឡូជីខល ដែលផ្តល់នូវភាពបត់បែនកាន់តែច្រើនក្នុងការសរសេរកម្មវិធី។ លើសពីនេះ លក្ខខណ្ឌអាចត្រូវបានវាយតម្លៃដោយផ្អែកលើកន្សោមប៊ូលីនណាមួយ ដូចជាតម្លៃនៃអថេរ លទ្ធផលនៃអនុគមន៍ ឬការរួមបញ្ចូលគ្នានៃទាំងពីរ។ នេះអនុញ្ញាតឱ្យបង្កើតវដ្ត ខណៈពេល ដែលសម្របខ្លួនទៅនឹងស្ថានភាពផ្សេងៗ និងលក្ខណៈវិនិច្ឆ័យនៃការបញ្ចប់។
ឧទាហរណ៍ជាក់ស្តែងនៃការអនុវត្ត ខណៈពេលដែលវដ្ត
El រង្វិលជុំខណៈពេល គឺជារចនាសម្ព័ន្ធគ្រប់គ្រងនៅក្នុង Python ដែលអនុញ្ញាតឱ្យប្លុកកូដត្រូវបានធ្វើម្តងទៀតដរាបណាលក្ខខណ្ឌជាក់លាក់មួយត្រូវបានបំពេញ។ រចនាសម្ព័ននេះគឺល្អនៅពេលដែលអ្នកមិនដឹងច្បាស់ពីចំនួនដងដែលអ្នកចង់សរសេរកូដឡើងវិញ ព្រោះវាត្រូវបានប្រតិបត្តិរហូតដល់លក្ខខណ្ឌវាយតម្លៃថាមិនពិត។
ឧទាហរណ៍ ១៖
ឧបមាថាយើងចង់បោះពុម្ពលេខ 1 ដល់ 10 នៅក្នុងកុងសូល។ យើងអាចប្រើ a ខណៈពេលដែលរង្វិលជុំ ដើម្បីសម្រេចបានវាដូចខាងក្រោម៖
``ពស់ថ្លាន់
លេខ = 1
ខណៈពេលដែលលេខ <= 10: បោះពុម្ព(លេខ) លេខ += 1 ```
ឧទាហរណ៍ ១៖
ករណីប្រើប្រាស់ទូទៅសម្រាប់ប្រើ while គឺជាពេលដែលអ្នកត្រូវការធ្វើអន្តរកម្មជាមួយអ្នកប្រើប្រាស់រហូតដល់ការបញ្ចូលត្រឹមត្រូវ។ ឧទាហរណ៍ ឧបមាថាយើងចង់សុំឱ្យអ្នកប្រើប្រាស់បញ្ចូលលេខធំជាងសូន្យ៖
``ពស់ថ្លាន់
លេខ = 0
ខណៈពេលដែលលេខ <= 0: num = int(input("សូមបញ្ចូលលេខធំជាងសូន្យ:")) print("លេខដែលបានបញ្ចូលគឺ:", num) ```
ឧទាហរណ៍ ១៖
សេណារីយ៉ូមួយទៀតដែលខណៈពេលដែលមានប្រយោជន៍គឺនៅពេលដែលអ្នកចង់ដំណើរការបញ្ជីនៃធាតុរហូតដល់លក្ខខណ្ឌជាក់លាក់មួយត្រូវបានបំពេញ។ ឧទាហរណ៍ ឧបមាថាយើងមានបញ្ជីឈ្មោះ ហើយយើងចង់បោះពុម្ពវាម្តងមួយៗ រហូតដល់ឈ្មោះ "John" ត្រូវបានរកឃើញ៖
``ពស់ថ្លាន់
names = ["Pedro", "María", "Juan", "Luisa"]
សន្ទស្សន៍ = ០
while names[index] != "John":
បោះពុម្ព(ឈ្មោះ[លិបិក្រម])
សន្ទស្សន៍ += 1
```
ដូចដែលយើងបានឃើញហើយថា while loop គឺជាឧបករណ៍ដែលអាចបត់បែនបាន និងមានឥទ្ធិពលដែលអនុញ្ញាតឱ្យយើងបង្កើតរចនាសម្ព័ន្ធគ្រប់គ្រងថាមវន្តបន្ថែមទៀតនៅក្នុងកម្មវិធីរបស់យើង។ វាមានសារៈសំខាន់ណាស់ក្នុងការប្រុងប្រយ័ត្នដើម្បីជៀសវាងការធ្លាក់ចូលទៅក្នុងក វដ្តគ្មានកំណត់, នោះគឺ មួយដែលមិនឈប់ឈរ ដោយសារលក្ខខណ្ឌកំណត់រចនាសម្ព័ន្ធខុស។ វាគឺជាទីប្រឹក្សាដើម្បីធានាថាលក្ខខណ្ឌនៃ while loop វាយតម្លៃទៅមិនពិតនៅចំណុចមួយចំនួន ដើម្បីកុំឱ្យកម្មវិធីដំណើរការដោយគ្មានកំណត់។
while loop គឺជារចនាសម្ព័ន្ធគ្រប់គ្រងនៅក្នុង Python ដែលត្រូវបានប្រើដើម្បីធ្វើប្លុកកូដឡើងវិញរហូតដល់លក្ខខណ្ឌជាក់លាក់មួយត្រូវបានបំពេញ។ មិនដូច for loop ទេ while loop មិនមានចំនួនថេរនៃពាក្យដដែលៗទេ ដោយសារការប្រតិបត្តិរបស់វាគឺផ្អែកលើការវាយតម្លៃនៃកន្សោមប៊ូលីន។
កន្សោមប៊ូលីននេះ។ដែលត្រូវបានគេស្គាល់ថាជាលក្ខខណ្ឌមួយ ត្រូវបានគេវាយតម្លៃនៅដើមនៃការធ្វើម្តងទៀតនៃរង្វិលជុំនីមួយៗ។ ប្រសិនបើលក្ខខណ្ឌគឺពិត ប្លុកកូដត្រូវបានប្រតិបត្តិម្តងទៀត។ ប្រសិនបើលក្ខខណ្ឌមិនពិត រង្វិលជុំឈប់ ហើយដំណើរការកម្មវិធីបន្តជាមួយជំហានបន្ទាប់។
ទិដ្ឋភាពសំខាន់ដែលត្រូវចងចាំនៅពេលធ្វើការជាមួយ while loop គឺថាអ្នកត្រូវតែធានាថាមានវិធីដើម្បីបញ្ចប់រង្វិលជុំ។ បើមិនដូច្នោះទេ រង្វិលជុំគ្មានកំណត់អាចត្រូវបានបង្កើត ដែលប្លុកកូដត្រូវបានប្រតិបត្តិម្តងហើយម្តងទៀតដោយមិនឈប់។ ដូច្នេះ វាចាំបាច់ណាស់ក្នុងការកំណត់លក្ខខណ្ឌដែលនៅទីបំផុតក្លាយជាមិនពិត ដើម្បីការពារកម្មវិធីពីការជាប់នៅក្នុងរង្វិលជុំគ្មានទីបញ្ចប់។
សរុបមក while loop គឺជាឧបករណ៍រង្វិលជុំដ៏មានអានុភាពនៅក្នុង Python ដែលអនុញ្ញាតឱ្យអ្នកប្រតិបត្តិប្លុកកូដរហូតដល់លក្ខខណ្ឌដែលបានផ្តល់ឱ្យគឺមិនពិត។ នៅពេលប្រើរង្វិលជុំនេះ វាចាំបាច់ណាស់ក្នុងការធានានូវលក្ខខណ្ឌបញ្ចប់មួយ ដើម្បីជៀសវាងរង្វិលជុំគ្មានកំណត់។ ជាមួយនឹងការរួមបញ្ចូលគ្នានៃ សម្រាប់ និងខណៈពេលរង្វិលជុំ អ្នកអាចដោះស្រាយបញ្ហាជាច្រើន និងរចនាសម្ព័ន្ធកម្មវិធីស្មុគ្រស្មាញ។
ខ្ញុំជា Sebastián Vidal ជាវិស្វករកុំព្យូទ័រដែលស្រលាញ់បច្ចេកវិទ្យា និង DIY ។ លើសពីនេះទៀតខ្ញុំជាអ្នកបង្កើត tecnobits.com ជាកន្លែងដែលខ្ញុំចែករំលែកការបង្រៀនដើម្បីធ្វើឱ្យបច្ចេកវិទ្យាកាន់តែអាចចូលប្រើបាន និងអាចយល់បានសម្រាប់អ្នករាល់គ្នា។