ពស់ថ្លាន់ - វាគឺជាអ្វី? ភាសាសរសេរកម្មវិធី-កម្រិតខ្ពស់

Python គឺជាការកម្រិតខ្ពស់ភាសាសកលដែលអាចត្រូវបានពង្រីកនិងបានបង្កប់។ លោកបាន, ឧទាហរណ៍, គឺជាសំណុំនៃកម្មវិធីដែលជាឧបករណ៍មួយសម្រាប់ម៉ាក្រូដែលបានសរសេរមួយ។ Python បានធ្វើឱ្យវាជាការសមហេតុផលសម្រាប់ភារកិច្ចជម្រើសជាច្រើនសរសេរកម្មវិធីទាំងធំទាំងតូចនិងមិនមានលក្ខណៈល្អមួយចំនួនតូចមួយនៃភារកិច្ចកុំព្យូទ័រ។

ដែលជាកន្លែងដែលខ្ញុំគួរប្រើ?

Python គឺល្អសម្រាប់គម្រោងដែលតម្រូវឱ្យមានការអភិវឌ្ឍយ៉ាងឆាប់រហ័ស។ វាគាំទ្រគំរូកម្មវិធីចម្រុះ, អ្វីដែលជាការល្អសម្រាប់កម្មវិធីដែលទាមទារភាពបត់បែន។ និងវត្តមាននៃពហុភាពនៃកញ្ចប់និងម៉ូឌុលមួយផ្តល់នូវភាពបត់បែននិងរក្សាទុកពេលវេលា។

លោក Guido ឡាន Rossum - អ្នកបង្កើត, Python, សហគមន៍ពានរង្វាន់ដោយសប្បុរសចំណងជើងនៃ "ជនផ្តាច់ក្ដីមេត្តាករុណាចំពោះជីវិត»។ នៅទសវត្សរ៍ឆ្នាំ 1980 ចុងលោក Guido ចូលចិត្តលក្ខណៈពិសេសនៃភាសាសរសេរកម្មវិធីមួយចំនួន, ប៉ុន្តែគ្មាននរណាម្នាក់នៃពួកគេមានលក្ខណៈពិសេសដែលលោកចង់ឱ្យមានទាំងអស់។ ជាពិសេសនៅក្នុងភាសាដែលមានដើម្បីឱ្យមានលក្ខណៈដូចខាងក្រោម។

ស្គ្រីបភាសា

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

សហគមន៍អ្នកប្រើចូលចិត្តហៅភាសាសរសេរកម្មវិធីថាមវន្ត Python ។

ការចូលបន្ទាត់សម្រាប់ការដាក់ជាក្រុមនៃប្រតិបត្តិករនេះ

ពស់ថ្លាន់កំណត់កន្សោមដែលជាកម្មសិទ្ធិរបស់ក្រុមដូចគ្នានេះដែរដោយមានជំនួយពីចន្លោះនេះ។ ដូចជាក្រុមមួយដែលត្រូវបានគេហៅថាប្លុកកូដ។ ក្នុងភាសាផ្សេងទៀត, វាប្រើវាក្យសម្ព័ន្ធឬវណ្ណយុត្តផ្សេងគ្នា។ ឧទាហរណ៍, និមិត្តសញ្ញា C ដែលសញ្ញាជានិមិត្តរូបចាប់ផ្តើមនិង {} - ចុងបញ្ចប់នៃសេចក្ដីណែនាំលំដាប់។ វត្តមាននៃការចូលបន្ទាត់ត្រូវបានចាត់ទុកថាជាការអនុវត្តល្អក្នុងភាសាផ្សេងទៀត, ប៉ុន្តែមួយនៃការលើកដំបូងនៅក្នុងការដែលអ្នកសង្កេតការណ៍របស់កម្លាំងចូលបន្ទាត់នេះត្រូវបានផ្តល់ជូនគឺ Python ។ អ្វីដែលផ្តល់ឱ្យ? ចូលបន្ទាត់ធ្វើឱ្យកូដរបស់អ្នកកាន់តែងាយស្រួលក្នុងការអាននិងការតម្រូវឱ្យតិចប្លុកកូដរចនាម៉ូដរបស់ពួកគេនិងការចាប់ផ្តើមនៃការចុង, និងសញ្ញាវណ្ណយុត្តដែលអាចត្រូវបានលុបដោយចៃដន្យ។ ទាំងអស់នេះនាំឱ្យមានកំហុសតិចជាងមុន។

ប្រភេទទិន្នន័យកម្រិតខ្ពស់

កុំព្យូទ័ររក្សាទុកទិន្នន័យនៅក្នុងគ្រឿងនិងលេខសូន្យប៉ុន្តែមនុស្សចាំបាច់ត្រូវតែមានទម្រង់ស្មុគស្មាញជាច្រើនទៀតដូចជាអត្ថបទ។ អំពីភាសាដែលគាំទ្រទិន្នន័យស្មុគស្មាញដោយនិយាយថាវាគាំទ្រប្រភេទទិន្នន័យកម្រិតខ្ពស់។ ប្រភេទនៃទិន្នន័យទាំងនេះគឺជាការងាយស្រួលក្នុងការតិបត្តិការ។ ឧទាហរណ៍នៅក្នុងបន្ទាត់ Python ដែលអាចត្រូវបានចែកចេញ, បញ្ចូលគ្នា, បកប្រែក្នុងករណីខ្ពស់ឬទាបជាងនេះពួកគេអាចស្វែងរកនិងអាវ។ ឃប្រភេទទិន្នន័យកម្រិតខ្ពស់ដូចជាបញ្ជីនិងវចនានុក្រមដែលអាចត្រូវបានរក្សាទុកនិងទិន្នន័យផ្សេងទៀតដែលមានមុខងារជាច្រើនទៀត, ជាងភាសាផ្សេងទៀត។

ពង្រីក

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

ការបកស្រាយ

ភាសាដែលបានបកប្រែត្រូវបានធ្វើដោយផ្ទាល់ពីប្រភពកូដដែលបានសរសេរដោយមនុស្ស, និងកម្មវិធីសរសេរជាភាសាចងក្រងដូចជា C ++ ត្រូវតែត្រូវបានបកប្រែទៅជាកូដម៉ាស៊ីន។ ភាសាកម្មវិធីកុំព្យូទ័រមានសភាពយឺតជាងមុនចាប់តាំងពីការបកប្រែបានកើតឡើងនៅលើរហ័សនោះទេប៉ុន្តែកម្មវិធីកែកំហុសនិងសរសេរបានលឿនជាងមុនដោយសារតែនេះគឺមានតម្រូវការក្នុងការរង់ចាំសម្រាប់ការបញ្ចប់នៃការចងក្រងនោះទេ។ ពួកគេគឺមានភាពងាយស្រួលក្នុងការអនុវត្តលើវេទិកាផ្សេងគ្នា។

មនុស្សម្នាក់អាចអះអាងអំពីថាតើ Python បានបកស្រាយឬភាសាចងក្រង។ ទោះបីជាក្នុងវិធីជាច្រើនដែលគាត់បានធ្វើការជាប្រែថាមុនពេលប្រតិបត្តិកូដដែលត្រូវបានចងក្រង (ដូចនៅក្នុង Java) និងជាច្រើននៃសមាសភាគរបស់ខ្លួនកំពុងរត់នៅល្បឿនពេញលេញនៃម៉ាស៊ីននេះដូចដែលមានចែងទុកក្នុងគ

លោក Guido ចាប់ផ្តើមសរសេរ Python បានក្នុងអំឡុងពេលថ្ងៃឈប់សម្រាកបុណ្យណូអែលនៅក្នុងឆ្នាំ 1989 ហើយនៅឆ្នាំក្រោយនេះគាត់បានបញ្ចប់ភាសាបានដោយផ្អែកលើមតិរបស់មិត្តរួមការងាររបស់ពួកគេ។ សាធារណៈជនទូទៅបានឃើញលទ្ធផលនេះនៅខែកុម្ភៈឆ្នាំ 1991 នៅពេលដែលគាត់ត្រូវបានគេដាក់នៅក្នុងមួយនៃបណ្ដាញអ្នកប្រើក្រុមថ្មីជាច្រើនដូចជា។

ពស់ថ្លាន់សម្រាប់អ្នកចាប់ផ្តើមដំបូង

ក្នុងគោលបំណងដើម្បីចាប់ផ្តើមកម្មវិធីសរសេរនៅក្នុង Python, អ្នកចាំបាច់ត្រូវដំឡើងវា។ នៅក្នុងកំណែរបស់ Python 2.7 និង 3.5 Python បាន, មានភាពខុសគ្នាយ៉ាងសំខាន់ដោយសារតែមានចែងទុកក្នុងពួកគេកម្មវិធីដែលមានគឺមិនឆបគ្នាទេ។

នៅក្នុងកុំព្យូទ័រ, "McIntosh បាន" ភាសាដែលបានដំឡើងជាមុនហើយវាអាស្រ័យលើកំណែនៃប្រព័ន្ធប្រតិបត្តិការអាយុ។ នៅក្នុងវីនដូអាចមានដើម្បីដំឡើង Python ។ ឯកសារកញ្ចប់ដំឡើងអាចត្រូវបានជ្រើសនៅលើគេហទំព័រ python.org ។

វិធីពីរនៃទំនាក់ទំនង

មូលហេតុមួយនៃភាពសាមញ្ញ, ដែលត្រូវបានកំណត់សរសេរកម្មវិធីនៅក្នុង Python, គឺថាវាបានភ្ជាប់មកជាមួយឧបករណ៍ដែលជួយអ្នកក្នុងការអភិវឌ្ឍនិងកម្មវិធីបំបាត់កំហុសសរសេរ។

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

បរិស្ថានការអភិវឌ្ឍ IDLE របៀបអន្តរកម្មរួមបញ្ចូលជាមួយនិងឧបករណ៍ដើម្បីសរសេរនិងកម្មវិធីរត់ព្រមទាំងឈ្មោះនៃប្រព័ន្ធតាមដាននេះ។ កាលពីថ្ងៃពុធបានសរសេរនៅក្នុង Python និងបង្ហាញពីលទ្ធភាពធំទូលាយនៃភាសា។

របៀបអន្តរកម្ម

នៅទីនេះអ្នកអាចធ្វើបានស្ទើរតែអ្វីដែលអាចធ្វើបាននៅក្នុងកម្មវិធីនេះ, សូម្បីតែសរសេរកូដច្រើនបន្ទាត់។ របៀបនេះអាចជា:

• សេនបក់ចំពោះការពិសោធន៍ដែលមានសុវត្ថិភាព;
• បរិស្ថានអនុញ្ញាតឱ្យអ្នកសិក្សាសរសេរកម្មវិធីនៅក្នុង Python;
• ឧបករណ៍សម្រាប់ការស្វែងរកនិងការកែកំហុស។

រក្សាទុកក្នុងចិត្តថាដើម្បីរក្សាទុកដែលបានបញ្ចូលនៅក្នុងរបៀបអន្តរសកម្មគឺមិនអាចទៅរួចទេ។ ដើម្បីធ្វើដូចនេះអ្នកចម្លងកូដនិងកត់ត្រាក្នុងឯកសារមួយ។

របៀបអន្តរកម្មអាចត្រូវបានប្រើជាម៉ាស៊ីនគិតលេខរៀបចំអត្ថបទនិងផ្តល់តម្លៃទៅឱ្យអថេរ។ អ្នកអាចនាំចូលម៉ូឌុល, មុខងារ, ឬជាផ្នែកនៃកម្មវិធីសាកល្បងពួកគេ។ វាអាចជួយក្នុងការពិសោធន៍ជាមួយនឹងវត្ថុ Python បានដោយគ្មានការសរសេរកម្មវិធីនិងកម្មវិធីបំបាត់កំហុសជាយូរមកហើយការនាំចូលគ្រឿងបន្លាស់មួយដោយនៅពេលតែមួយ។

ធ្វើការលើបណ្តាញ

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

ទៅធ្វើការនៅក្នុងរបៀបអន្តរសកម្ម, បញ្ចូលពាក្យបញ្ជាឬការបញ្ចេញមតិហើយចុចគ្រាប់ចុចបញ្ចូល។

ពស់ថ្លាន់បកប្រែការបញ្ចូលនិងប្រតិកម្មប្រសិនបើការវាយការឆ្លើយតបមួយដែលតម្រូវឱ្យឬបកប្រែមិនយល់គាត់។

ពាក្យបញ្ជាខាងក្រោមនឹងបោះពុម្ពបន្ទាត់។ ចាប់តាំងពីទីតាំងបោះពុម្ពមិនត្រូវបានបញ្ជាក់, ទិន្នផលទៅអេក្រង់។

• >>> បោះពុម្ព "ជំរាបសួរពិភពលោក! »
• ជំរាបសួរពិភពលោក!

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

មើលអំពីវត្ថុ

ក្នុងរបៀបអន្តរសកម្ម, មានវិធីពីរយ៉ាងដើម្បីមើលអំពីវត្ថុនោះគឺ:

• ដាក់វត្ថុ (ឬឈ្មោះ) ហើយចុចបញ្ចូល;
• បញ្ចូលពាក្យបញ្ជាបោះពុម្ពនិងវត្ថុ (ឬឈ្មោះ) ហើយចុចបញ្ចូល។

លទ្ធផលនេះគឺអាស្រ័យលើវត្ថុ។

ជាមួយនឹងប្រភេទទិន្នន័យមួយចំនួន (ចំនួនគត់និងបញ្ជីឧទាហរណ៍) វិធីសាស្រ្តទាំងពីរនេះផលិតបានលទ្ធផលដូចគ្នា:

• >>> X = [3,2]
• >>> x
• [3, 2]
• >>> បោះពុម្ព x
• [3, 2]

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

• >>> X = "MyString"
• >>> x
• "MyString"
• >>> បោះពុម្ព x
• MyString

នៅពេលដែលឈ្មោះនេះសំដៅទៅលើប្លុកនៃកូដ (ឧទាហរណ៍, មុខងារ, ម៉ូឌុលឬឧទាហរណ៍ថ្នាក់), បញ្ចូលឈ្មោះនេះនឹងផ្ដល់ពអំពីប្រភេទនៃទិន្នន័យឈ្មោះនិងទីកន្លែងនៃការផ្ទុក។

ឧទាហរណ៍ដូចខាងក្រោមបង្កើតថ្នាក់ដែលគេហៅថាសារនិងបង្ហាញអំពីការ

វា:

• >>> សារថ្នាក់:
• ... ឆ្លង
• ...
• >>> សារ
• <ថ្នាក់ ___ ___ សំខាន់។ សារនៅ 0x58db0>
• >>> សារបោះពុម្ព
• __main __ ។ សារ

បន្ទាត់

បន្ទាត់ Python បានមានលំដាប់នៃតួអក្សរ។ ខ្សែអក្សរមួយមែនទែនត្រូវបានបង្កើតដោយការបញ្ចូលតួអក្សរនៅក្នុងសញ្ញាសម្រង់ទោល ( '), ( ") ពីរដងឬបីដង (' 'ឬ" "") សញ្ញាសម្រង់។ នៅក្នុងឧទាហរណ៍នេះតម្លៃដែលបានផ្ដល់ទៅឱ្យអថេរ x:

• >>> X = "MyString"

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

• >>> x.lower ()
• "Mystring"

អ្នកអាចទទួលបានជាផ្នែកមួយនៃបន្ទាត់ដោយប្រើប្រតិបត្តិករលិបិក្រមរបស់ [i] ។ ការបង្កើតលិបិក្រមចាប់ផ្តើមនៅសូន្យដូច្នេះនេះ [0] ត្រឡប់តួអក្សរដំបូងក្នុងខ្សែអក្សរនេះជា [1] ត្រឡប់ទីពីរហើយដូច្នេះនៅលើ:

• >>> x [0]
• ', M'
• >>> x [1]
• 'y'

វិធីសាស្រ្តខ្សែអក្សរធ្វើការបន្ទាត់សាមញ្ញដែលជានិងជាមួយ "យូនីកូដ" ។ ពួកគេផលិតដូចខាងក្រោម:

• ចុះឈ្មោះការផ្លាស់ប្តូរ (ចំណេញ, ខាងលើ, ទាប, swapcase ចំណងជើង,);
• រាប់ (រាប់);
• ផ្លាស់ប្ដូរការអ៊ិនកូដ (អ៊ិនកូដឌិកូដ,);
• ស្វែងរកនិងជំនួស (រកឃើញ, ជំនួស, rfind សន្ទស្សន៍ rindex បកប្រែ);
• ពិនិត្យមើលលក្ខខណ្ឌ (startswith, endswith, isalnum, isalpha, isdigit, islower, isspace, istitle, isupper);
• រួមបញ្ចូលគ្នានិងបំបែក (ចូលរួមភាគថាស, rpartition, បំបែក, splitlines);
• ទ្រង់ទ្រាយ (កណ្តាល, ljust, lstrip, rstring, rjust, បន្ទះ, zfill, expandtabs) ។

ពស់ថ្លាន់: បញ្ជី

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

• >>> មូលដ្ឋាន = [ 'A', 'C', 'G' 'T']
• មូលដ្ឋាន >>>
• [ 'A', 'C', 'G' 'T']
• >>> bases.append ( 'U')
• មូលដ្ឋាន >>>
• [ 'A', 'C', 'G' 'T', 'U']
• >>> bases.reverse ()
• មូលដ្ឋាន >>>
• [ 'U', 'T មាន', 'G' 'c', 'មួយ']
• មូលដ្ឋាន >>> [0]
• 'U'
• មូលដ្ឋាន >>> [1]
• "ក្រុមហ៊ុន T"
• >>> bases.remove ( 'U')
• មូលដ្ឋាន >>>
• [ 'T មាន', 'G' 'c', 'មួយ']
• >>> bases.sort ()
• មូលដ្ឋាន >>>
• [ 'A', 'C', 'G' 'T']

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

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

ពស់ថ្លាន់: មុខងារ

មុខងារអនុវត្តប្រតិបត្តិការលើតម្លៃមួយឬច្រើននិងត្រឡប់លទ្ធផល។ ចំនួនធំនៃពួកគេត្រូវបានគេសាងសង់ឡើងនៅក្នុង Python ។ ឧទាហរណ៍នៃមុខងារកសាងឡើងនៅក្នុង:

• LEN () - ត្រឡប់ចំនួនធាតុនៅក្នុងលំដាប់នេះ;
• dir () - ត្រឡប់បញ្ជីនៃខ្សែអក្សរដែលតំណាងឱ្យលក្ខណៈនៃវត្ថុមួយ;
• បញ្ជី () - ត្រឡប់បញ្ជីថ្មីបានចាប់ផ្ដើមពីលំដាប់ចំនួនផ្សេងទៀត។
• >>> ជំនួយ (ជុំ)
• ជំនួយលើមុខងារកសាងឡើងនៅក្នុងការប្រកួតជុំទី:
• ជុំ ( ... )
• ជុំ (ចំនួន [, ndigits]) -> ចំនួនចំណុចអណ្តែតទឹក

វាគឺអាចធ្វើបានផងដែរដើម្បីកំណត់អនុគមន៍ផ្ទាល់ខ្លួនរបស់អ្នក។

មុខងារដែលកំណត់ដោយអ្នកប្រើ

ដំណើរការនៃការបង្កើតមុខងារ Python បានផ្ទាល់ខ្លួនរបស់វានោះ។ បន្ទាត់ដំបូងបានចាប់ផ្តើមជាមួយនឹងការដោពាក្យគន្លឹះដែលបានតាមពីក្រោយដោយឈ្មោះអនុគមន៍និងអាគុយម៉ង់ (តម្លៃបញ្ចូលរំពឹងថានឹងមាន) ដែលបានរុំព័ទ្ធក្នុងវង់ក្រចក, និងបញ្ចប់ដោយសញ្ញា។ ពាក្យបញ្ជាជាបន្តបន្ទាប់ធ្វើឱ្យកើនឡើងមុខងាររាងកាយហើយត្រូវបានចូលបន្ទាត់។ ប្រសិនបើមានការអត្ថាធិប្បាយមួយដែលមានទីតាំងនៅដើមដំបូងនៃរាងកាយមុខងារនេះវាបានក្លាយទៅជាផ្នែកមួយនៃឯកសាររបស់ខ្លួន។ បន្ទាត់ចុងក្រោយនៃអនុគមន៍ត្រឡប់លទ្ធផល:

• >>> ដោចម្លង (DNA):
• ... "" "ត្រឡប់ខ្សែអក្សរ DNA ជាខ្សែអក្សរ RNA ។ " ""
• ... dna.replace ត្រឡប់មកវិញ ( 'T មាន', 'U')
• ...
• >>> ចម្លង ( 'CCGGAAGAGCTTACTTAG')
• "CCGGAAGAGCUUACUUAG"

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

• >>> ដោបញ្ច្រាស (s បាន):
• ... "" "ត្រឡប់ខ្សែអក្សរលំដាប់ក្នុងលំដាប់បញ្ច្រាស។ " ""
• ... អក្សរ = បញ្ជី (s បាន)
• ... letters.reverse ()
• ... ត្រឡប់មកវិញ "" .join (អក្សរ)
• ...
• >>> ផ្ទុយ ( 'CCGGAAGAGCTTACTTAG')
• "GATTCATTCGAGAAGGCC"

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

វចនានុក្រម

វចនានុក្រម Python បានមួយ - វាគឺជាអ្វី? វាមានផលប្រយោជន៍ដូចគ្នានឹងក្រដាសធម្មតាវចនានុក្រម។ វាអនុញ្ញាតឱ្យអ្នកស្វែងរកតម្លៃដែលចង់បាន (និយមន័យ) បានភ្ជាប់ជាមួយនឹងកូនសោមួយ (ពាក្យ) យ៉ាងឆាប់រហ័ស។ វចនានុក្រមត្រូវបានរុំព័ទ្ធក្នុងដង្កៀបនិងបានបំបែកដោយសញ្ញាក្បៀសមានលំដាប់នៃគូតម្លៃគ្រាប់ចុចមួយ។ វចនានុក្រមមិនត្រូវបានបញ្ជាឱ្យ។ ផ្ទុយទៅវិញតម្លៃវចនានុក្រមដែលអាចរកបានតាមរយៈគ្រាប់ចុចរបស់ពួកគេមិនមែនជាជំហររបស់ពួកគេ។

• >>> basecomplement = { 'A': 'T មាន', 'C': 'G' 'T': 'A', 'G': 'c'}
• >>> basecomplement.keys ()
• [ 'A', 'C', 'T មាន', 'G']
• >>> basecomplement.values ()
• [ 'T មាន', 'G' 'A', 'C']
• >>> basecomplement [ 'A']
• "ក្រុមហ៊ុន T"

ថ្នាក់

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

គុណសម្បត្តិ

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

• ភាសាអាចត្រូវបានរួមបញ្ចូលទៅក្នុងកម្មវិធីផ្សេងនិងត្រូវបានប្រើដើម្បីបង្កើតម៉ាក្រូ។ ឧទាហរណ៍នៅក្នុងហាងលក់ថ្នាំលាបគាំទ្រ 8 ឬ, វាគឺជាភាសាស្គ្រីបមួយ។
• Python គឺដោយឥតគិតថ្លៃសម្រាប់ការប្រើប្រាស់និងការចែកចាយនៅលើមូលដ្ឋានពាណិជ្ជកម្មឬមិនបាន។
• ភាសាមានសមត្ថភាពដំណើរការមួយដែលមានអនុភាពនិងការស្វែងរកអត្ថបទដែលត្រូវបានប្រើនៅក្នុងកម្មវិធីធ្វើការជាមួយនឹងការជាច្រើននៃពអត្ថបទមួយ។
• វាគឺជាការដែលអាចធ្វើបានដើម្បីបង្កើតកម្មវិធីធំដោយមិនចាំបាច់ដើម្បីពិនិត្យមើលកម្មវិធីចាប់ផ្ដើម។
• ពស់ថ្លាន់ការកែកំហុសនិងការធ្វើតេស្តការគាំទ្ររបស់បុគ្គលនិងកម្មវិធីម៉ូឌុលទាំងមូល។