ឥឡូវនេះ Python គឺជាភាសាដែលប្រើច្រើនបំផុតនៅលើ GitHub ហើយការដោះស្រាយអត្ថបទគឺជាកិច្ចការទូទៅសម្រាប់អ្នកអភិវឌ្ឍន៍។ ការភ្ជាប់ខ្សែអក្សរ – រួមបញ្ចូលគ្នានូវបំណែកជាច្រើននៃអត្ថបទទៅជាមួយ – គឺជាប្រតិបត្តិការមូលដ្ឋាន។ សម្រាប់កិច្ចការជាច្រើន អ្នកសរសេរកម្មវិធីត្រូវតែ python concatenate strings (ឃ្លាពិតប្រាកដលេចឡើងក្នុងការស្វែងរក) ដើម្បីបង្កើតលទ្ធផលដែលមានន័យ។ អត្ថបទនេះពន្យល់ពីវិធីងាយៗចំនួនប្រាំដើម្បីភ្ជាប់ខ្សែអក្សរនៅក្នុង Python ។ វិធីសាស្រ្តនីមួយៗត្រូវបានបង្ហាញជាមួយឧទាហរណ៍ និងគាំទ្រដោយឯកសារយោង។ គោលដៅគឺផ្តល់ឱ្យអ្នកអភិវឌ្ឍន៍នូវវិធីជាក់ស្តែង និងច្បាស់លាស់ក្នុងការបញ្ចូលអត្ថបទ និងការយល់ដឹងអំពីពេលណាដែលត្រូវប្រើវិធីសាស្ត្រនីមួយៗ។
ខ្សែអក្សរ Python គឺមិនអាចផ្លាស់ប្តូរបាន ដូច្នេះការភ្ជាប់ដោយឆោតល្ងង់អាចគ្មានប្រសិទ្ធភាព។ ឧទាហរណ៍ដោយប្រើ + operator គឺសាមញ្ញ ប៉ុន្តែបង្កើត string ថ្មីរាល់ពេល។ ផ្ទុយទៅវិញវិធីសាស្រ្តដូចជា ចូលរួម() គ្រប់គ្រងខ្សែច្រើនយ៉ាងមានប្រសិទ្ធភាពជាង។ យើងនឹងគ្របដណ្តប់វិធីសាស្រ្តទូទៅ (+, ចូលរួម(), f-strings, ទម្រង់(), និង % ប្រតិបត្តិករ) និងចំណាំការអនុវត្ត និងករណីប្រើប្រាស់។ ផ្នែកនីមួយៗខាងក្រោមពិពណ៌នាអំពីវិធីសាស្ត្រ ជាញឹកញាប់ជាមួយកូដគំរូ និងដកស្រង់ប្រភពដែលមានការអនុញ្ញាត។ នៅទីបញ្ចប់ អ្នកអភិវឌ្ឍន៍នឹងយល់ពីរបៀបភ្ជាប់ខ្សែអក្សរនៅក្នុង Python ប្រកបដោយប្រសិទ្ធភាព។ អានអត្ថបទនេះពី 1Byte ដើម្បីស្វែងយល់បន្ថែម។
ដោយប្រើ + ប្រតិបត្តិករ
វិធីសាមញ្ញបំផុតក្នុងការបញ្ចូលខ្សែអក្សរពីរនៅក្នុង Python គឺជាមួយនឹងសញ្ញាបូក (+) ។ ប្រតិបត្តិករនេះភ្ជាប់ខ្សែអក្សរពីចុងដល់ចុង។ ឧទាហរណ៍៖
s1 = "ជំរាបសួរ"
s2 = "ពិភពលោក"
លទ្ធផល = s1 + "" + s2
print(លទ្ធផល) # លទ្ធផល៖ Hello World
នៅក្នុងកូដនេះ ការបន្ថែម s1 និង s2 ជាមួយ + និងចន្លោះរវាងផលិត Hello World។ រូបភាពកូដខាងក្រោមបង្ហាញឧទាហរណ៍ស្រដៀងគ្នា។
ការប្រើ + ប្រតិបត្តិករនៅក្នុង Python ដោយផ្ទាល់បន្ថែមខ្សែមួយទៅមួយទៀត។ ក្នុងឧទាហរណ៍នេះ "កម្មវិធី" + "វិស្វករ" ផ្តល់ទិន្នផល វិស្វករកម្មវិធី. វិធីសាស្រ្តនេះដំណើរការលើប្រតិបត្តិករខ្សែអក្សរណាមួយ វាមានភាពត្រង់ និងអាចអានបាន ដែលធ្វើឱ្យវាក្លាយជាកិច្ចការតូចតាច។
ទោះយ៉ាងណាក៏ដោយ ការប្រើ + ក្នុងរង្វិលជុំ ឬជាមួយខ្សែជាច្រើនអាចយឺត។ ដោយសារខ្សែអក្សរ Python មិនអាចផ្លាស់ប្តូរបាន នីមួយៗ + បង្កើតវត្ថុខ្សែអក្សរថ្មី។ នេះមានន័យថាការភ្ជាប់ម្តងហើយម្តងទៀត (ជាពិសេសនៅក្នុងរង្វិលជុំ) អាចប្រើអង្គចងចាំបន្ថែម និងពេលវេលា។ នៅក្នុងការអនុវត្ត + គឺល្អសម្រាប់ខ្សែពីរបី។ សម្រាប់លំដាប់ធំជាងនេះ វិធីសាស្ត្រផ្សេងទៀតដូចជា join() ត្រូវបានណែនាំ។ ទោះយ៉ាងណាក៏ដោយ សម្រាប់ការបញ្ចូលគ្នាយ៉ាងរហ័សនៃខ្សែពីរ ឬបី ប្រតិបត្តិករ + គឺងាយស្រួលប្រើបំផុត។
ដោយប្រើវិធីសាស្រ្ត join()
នៅពេលភ្ជាប់ខ្សែអក្សរជាច្រើនក្នុងពេលតែមួយ (ឧទាហរណ៍ ធាតុទាំងអស់ក្នុងបញ្ជីមួយ) វិធីសាស្ត្រ str.join() ដែលភ្ជាប់មកជាមួយគឺល្អបំផុត។ អ្នកហៅ join() នៅលើខ្សែអក្សរបំបែកមួយ ហើយឆ្លងកាត់ខ្សែអក្សរដែលអាចធ្វើបាន។ ឧទាហរណ៍ ដើម្បីភ្ជាប់ពាក្យដោយដកឃ្លា៖
ពាក្យ = [“Python”, “គឺ”, “ប្រសិទ្ធភាព”]
លទ្ធផល = ” “.ចូលរួម(ពាក្យ)
print(លទ្ធផល) # លទ្ធផល៖ Python មានប្រសិទ្ធភាព
វាបង្កើតខ្សែអក្សរមួយ Python មានប្រសិទ្ធភាពក្នុងប្រតិបត្តិការតែមួយ។ វិធីសាស្ត្រ join() ជៀសវាងការបង្កើតខ្សែកម្រិតមធ្យម ហើយដូច្នេះមានប្រសិទ្ធភាពណាស់។ តាមពិត ឯកសារកត់ចំណាំថា join() មាន ខ្ពស់ ប្រសិទ្ធភាពនៃការចងចាំព្រោះវាបង្កើតខ្សែអក្សរចុងក្រោយក្នុងពេលតែមួយ។ ផ្ទុយទៅវិញ ការភ្ជាប់ជាមួយ + ត្រូវបានសម្គាល់ ទាប ប្រសិទ្ធភាព (វាបង្កើតវត្ថុខ្សែអក្សរថ្មីរាល់ពេល)។
វិធីសាស្ត្រ join() ភ្ជាប់បញ្ជីខ្សែអក្សរដោយប្រើខ្សែអក្សរដែលវាត្រូវបានហៅជាសញ្ញាបំបែក។ ក្នុងឧទាហរណ៍កូដនេះ string1 = “Generative” និង string2 = “AI” ត្រូវបានភ្ជាប់ដោយ ” “.join() ផលិត AI បង្កើត. នេះបង្ហាញពីរបៀបដែល join() ដំណើរការ៖ យើងហៅវានៅលើខ្សែអក្សរបំបែក (នៅទីនេះចន្លោះមួយ) ហើយឆ្លងកាត់បញ្ជី ["Generative", "AI"] ។ លទ្ធផលគឺខ្សែតែមួយដែលមានធាតុបំបែកដោយចន្លោះនោះ។
ជាទូទៅ Join() ត្រូវបានណែនាំសម្រាប់ការភ្ជាប់ខ្សែច្រើន ជាពិសេសនៅក្នុងកូដដែលងាយនឹងដំណើរការ។ មគ្គុទ្ទេសក៍រចនាប័ទ្ម Python (PEP 8) ណែនាំជាពិសេស ”.join() ក្នុងករណីដែលខ្សែអក្សរជាច្រើនត្រូវបានបញ្ចូលគ្នា ដើម្បីធានាបាននូវដំណើរការតាមពេលវេលាលីនេអ៊ែរ។ ការប្រើប្រាស់ join() ក៏អនុញ្ញាតឱ្យអ្នកបន្ថែមសញ្ញាកំណត់ព្រំដែនណាមួយបានយ៉ាងងាយស្រួល (ចន្លោះ សញ្ញាក្បៀស សហសញ្ញា។ TypeError ប្រសិនបើធាតុណាមួយមិនមែនជាខ្សែអក្សរ ប៉ុន្តែវាអាចត្រូវបានដោះស្រាយដោយការបំប្លែងជាមួយ str() ជាមុនសិន (ឧ. ការប្រើកន្សោមម៉ាស៊ីនភ្លើង) សរុបមក join() លឿន ងាយស្រួលចងចាំ និងល្អសម្រាប់ការបញ្ចូលគ្នានូវបញ្ជី ឬខ្សែអក្សរមួយចំនួនធំ។
ការប្រើប្រាស់ f-Strings (Formatted String Literals)
បានណែនាំនៅក្នុង Python 3.6, f-strings ផ្តល់នូវវិធីសង្ខេបដើម្បីបង្កប់អថេរ និងកន្សោមនៅខាងក្នុងអក្សរអក្សរ។ ពួកវាត្រូវបានគេប្រើជាញឹកញាប់ជាទម្រង់នៃការភ្ជាប់គ្នា នៅពេលដែលអ្នកត្រូវការបញ្ចូលខ្លឹមសារថាមវន្ត។ ខ្សែអក្សរ f ត្រូវបានសរសេរដោយបុព្វបទ f និងដង្កៀប {} ជុំវិញកន្សោម។ ឧទាហរណ៍៖
ដំបូង = "Jane"
ចុងក្រោយ = "Doe"
ពេញ = f”{first} {last}”
បោះពុម្ព (ពេញ) # លទ្ធផល៖ Jane Doe
នៅទីនេះឈ្មោះត្រូវបានបញ្ចូលទៅក្នុងខ្សែអក្សរ បង្កើត Jane Doe។ F-strings បម្លែងតម្លៃដោយស្វ័យប្រវត្តិទៅជា string ដូច្នេះអ្នកមិនចាំបាច់ហៅ str() ច្បាស់លាស់ទេ។
ខ្សែអក្សរ F មិនត្រឹមតែងាយស្រួលអាន និងសរសេរប៉ុណ្ណោះទេ ប៉ុន្តែថែមទាំងមានប្រសិទ្ធភាពខ្ពស់ទៀតផង។ នៅក្នុងការប្រៀបធៀបការអនុវត្ត ខ្សែអក្សរ f មានទំនោរលឿនជាង % operator (printf-style) និងលឿនជាងការប្រើ + សម្រាប់ខ្សែពីរ ឬបី។ គោលមួយ (សម្រាប់ការភ្ជាប់ខ្សែពីរ) បានរាយការណ៍ថា f-strings នៅ ~110 ns ធៀបនឹង % នៅ ~160 ns និង + នៅ ~176 ns (ជាមួយ join() នៅជុំវិញ 130 ns) ។ ជាទូទៅ DigitalOcean កត់ចំណាំថា join() មានប្រសិទ្ធភាពបំផុតសម្រាប់ខ្សែអក្សរជាច្រើន អមដោយ f-strings សម្រាប់អត្ថបទដែលបានធ្វើទ្រង់ទ្រាយ។ នេះមានន័យថា f-strings គឺជាជម្រើសកំពូល នៅពេលដែលអ្នកត្រូវការបង្កើត string ជាមួយអថេរ។
លើសពីការភ្ជាប់សាមញ្ញ ខ្សែអក្សរ f អនុញ្ញាតឱ្យមានកន្សោមស្មុគស្មាញ និងការធ្វើទ្រង់ទ្រាយនៅខាងក្នុងដង្កៀប។ ឧទាហរណ៍ f"Items: {','.join(items)}" អាចផ្សំ join() និង f-strings។ ពួកគេក៏ត្រូវបានណែនាំសម្រាប់កូដថ្មី ហើយបានក្លាយជាវិធីដែល Python ពេញចិត្តក្នុងការធ្វើទ្រង់ទ្រាយខ្សែអក្សរ (PEP 498)។ សរុបមក ខ្សែអក្សរ f ផ្តល់នូវមធ្យោបាយដ៏មានឥទ្ធិពល និងរហ័ស python ភ្ជាប់ខ្សែអក្សរ ជាមួយនឹងអថេរ ផ្តល់ទាំងភាពច្បាស់លាស់ និងដំណើរការល្អ។
ដោយប្រើវិធីសាស្ត្រ str.format()
វិធីសាស្ត្រ format() នៅលើ strings គឺជាវិធីមួយផ្សេងទៀតដើម្បីបញ្ចូលគ្នានូវអត្ថបទ និងអថេរ។ វាអាចប្រើបានតាំងពី Python 2.6 ហើយផ្តល់នូវទម្រង់ដែលអាចបត់បែនបាន។ អ្នកសរសេរខ្សែអក្សរគំរូជាមួយកន្លែងដាក់ {} ឬវាលដែលមានឈ្មោះ ហើយហៅ .format() ជាមួយនឹងតម្លៃ។ ឧទាហរណ៍៖
s1 = "ជំរាបសួរ"
s2 = "ពិភពលោក"
s3 = “{} {}”.format(s1, s2)
print(s3) # លទ្ធផល៖ Hello World
វាបញ្ចូល s1 និង s2 ទៅក្នុងកន្លែងដាក់តាមលំដាប់លំដោយ។ អ្នកក៏អាចប្រើកន្លែងដាក់ឈ្មោះ៖ “{a}-{b}”.format(a=s1, b=s2) នឹងដាក់ s1 និង s2 នៅ {a} និង {b} រៀងគ្នា។ កូដខាងលើបង្កើត Hello World ដោយប្រើទម្រង់។
វិធីសាស្ត្រ format() មានថាមពលខ្លាំងសម្រាប់ខ្សែអក្សរថាមវន្ត។ វាអាចធ្វើបានច្រើនជាងការបញ្ចូលគ្នាសាមញ្ញ (ដូចជាការធ្វើទ្រង់ទ្រាយលេខ ឬការដាក់បន្ទះ) ប៉ុន្តែវាក៏អាចបម្រើដើម្បីភ្ជាប់អត្ថបទផងដែរ។ ឧទាហរណ៍ “{in1} {in2}”.format(in1=s1, in2=s2) ក៏ផ្តល់ឱ្យ Hello World (ដូចបង្ហាញក្នុងលទ្ធផលយោង)។ DigitalOcean ផ្តល់យោបល់ថាមុខងារ format() មានប្រយោជន៍នៅពេលធ្វើការជាមួយតម្លៃថាមវន្ត។
នៅក្នុងលក្ខខណ្ឌនៃការអនុវត្ត ទ្រង់ទ្រាយ() បង្កើតវត្ថុកម្រិតមធ្យម ដូច្នេះវាមិនលឿនដូច f-strings ឬ join() ទេ។ សេចក្តីសង្ខេបរបស់ DigitalOcean បង្ហាញទម្រង់ () ដែលត្រូវបានសម្គាល់ថាជាការអនុវត្ត “កម្រិតមធ្យម”។ សម្រាប់ការងារភាគច្រើន វាល្អ ប៉ុន្តែប្រសិនបើល្បឿនមានសារៈសំខាន់ ហើយអ្នកមាន Python 3.6+ នោះ f-strings ជាធម្មតាត្រូវបានគេពេញចិត្ត។ ទោះយ៉ាងណាក៏ដោយ format() គឺជារឿងធម្មតាណាស់នៅក្នុងកូដដែលមានស្រាប់ ហើយមានភាពបត់បែនជាង % operator។ វាក៏ហៅដោយស្វ័យប្រវត្តិ str() លើអាគុយម៉ង់ដែលមិនមែនជាខ្សែ។ នៅក្នុងការអនុវត្ត ប្រើទម្រង់() នៅពេលដែលអ្នកត្រូវការលក្ខណៈពិសេសទម្រង់របស់វា (ដូចជាការធ្វើទ្រង់ទ្រាយលេខ) ឬប្រសិនបើអ្នកចង់ឱ្យវាអានបាន។ បើមិនដូច្នោះទេ សម្រាប់ការភ្ជាប់សាមញ្ញ f-strings ឬ join() ច្រើនតែប្រសើរជាង។
ការប្រើប្រាស់ % ប្រតិបត្តិករ (រចនាប័ទ្មចាស់)
% operator (printf-style) គឺជាវិធីចាស់ដើម្បីធ្វើទ្រង់ទ្រាយខ្សែអក្សរនៅក្នុង Python ។ វាក៏អាចភ្ជាប់ដោយការធ្វើទ្រង់ទ្រាយខ្សែអក្សរទៅក្នុងគំរូមួយ។ ឧទាហរណ៍៖
s1 = "ជំរាបសួរ"
s2 = "ពិភពលោក"
s3 = “%s %s” % (s1, s2)
print(s3) # លទ្ធផល៖ Hello World
នៅទីនេះ កន្លែងដាក់ %s ត្រូវបានជំនួសដោយ s1 និង s2។ វាបោះពុម្ព Hello World។ អ្នកអាចលាយប្រភេទឧទាហរណ៍ “%s %d” % (ឈ្មោះ អាយុ) នឹងបំប្លែង និងបញ្ចូលលេខ។ រូបភាពឧទាហរណ៍ខាងក្រោមបង្ហាញពីការប្រើប្រាស់ % operator៖
រូបថតអេក្រង់នេះបង្ហាញពីការភ្ជាប់ខ្សែអក្សរជាមួយប្រតិបត្តិករ % ។ ការបោះពុម្ពលេខកូដ (“%s %s” % (string1, string2)) បញ្ចូល string1 និង string2 ចូលទៅក្នុងបន្ទាត់តែមួយ (នៅទីនេះ AI បង្កើត).
វិធីសាស្ត្រ % ឥឡូវនេះត្រូវបានគេចាត់ទុកថាហួសសម័យបន្តិចហើយ ប៉ុន្តែវានៅតែបង្ហាញក្នុងកូដកេរដំណែល។ ជាទូទៅវាត្រូវបានណែនាំតិចជាងសម្រាប់កូដថ្មី ដោយសារ f-strings និង format() មានថាមពល និងសុវត្ថិភាពជាង។ នៅក្នុងលក្ខខណ្ឌនៃការអនុវត្ត ការធ្វើទ្រង់ទ្រាយរចនាប័ទ្មចាស់ជាធម្មតាយឺតជាង f-strings និង join() ប៉ុន្តែលឿនជាងប្រតិបត្តិការ + ច្រើនសម្រាប់តម្លៃពីរបី។ ឧទាហរណ៍ ការធ្វើតេស្តតូចមួយបានបង្ហាញ % នៅប្រហែល 160 ns ធៀបនឹង f-string នៅ 110 ns សម្រាប់ការភ្ជាប់ពីរខ្សែ។ សរុបមក % អាចភ្ជាប់ និងធ្វើទ្រង់ទ្រាយ ប៉ុន្តែកូដទំនើបភាគច្រើនប្រើ f-strings ឬ format() ជំនួសវិញ។ វាជាការល្អក្នុងការដឹង % នៅពេលអានកូដចាស់ ប៉ុន្តែការអភិវឌ្ឍន៍ថ្មីជាធម្មតាចូលចិត្តវិធីសាស្ត្រថ្មីជាងនេះ។
ប្រើប្រាស់ជំនាញ Cloud Computing ដ៏រឹងមាំរបស់ 1Byte ដើម្បីជំរុញអាជីវកម្មរបស់អ្នកតាមរបៀបដ៏ធំមួយ
1Byte ផ្តល់ពេញលេញ domain សេវាកម្មចុះឈ្មោះដែលរួមមានបុគ្គលិកគាំទ្រដោយយកចិត្តទុកដាក់ ការថែទាំអតិថិជនដែលមានការអប់រំ ការចំណាយសមរម្យ ក៏ដូចជា ក domain ឧបករណ៍ស្វែងរកតម្លៃ។
បង្កើនសុវត្ថិភាពលើអ៊ីនធឺណិតរបស់អ្នកជាមួយនឹងសេវាកម្ម SSL របស់ 1Byte ។ ការការពារដែលមិនអាចប្រៀបផ្ទឹមបាន ការរួមបញ្ចូលដោយគ្មានថ្នេរ និងសន្តិភាពនៃចិត្តសម្រាប់ដំណើរឌីជីថលរបស់អ្នក។
មិនថា cloud server កញ្ចប់ដែលអ្នកជ្រើសរើស អ្នកអាចពឹងផ្អែកលើ 1Byte សម្រាប់ភាពជឿជាក់ ភាពឯកជន សុវត្ថិភាព និងបទពិសោធន៍គ្មានភាពតានតឹង ដែលមានសារៈសំខាន់សម្រាប់អាជីវកម្មជោគជ័យ។
ការជ្រើសរើសពួកយើងជាអ្នកផ្តល់សេវាបង្ហោះចែករំលែករបស់អ្នកអនុញ្ញាតឱ្យអ្នកទទួលបានតម្លៃដ៏ល្អឥតខ្ចោះសម្រាប់ប្រាក់របស់អ្នក ខណៈពេលដែលរីករាយនឹងកម្រិតគុណភាព និងមុខងារដូចគ្នានឹងជម្រើសដែលមានតម្លៃថ្លៃជាង។
តាមរយៈកម្មវិធីដែលមានភាពបត់បែនខ្ពស់ 1Byte ដ៏ទំនើប cloud hosting ផ្តល់ដំណោះស្រាយដ៏អស្ចារ្យដល់អាជីវកម្មខ្នាតតូច និងមធ្យមលឿនជាងមុន សុវត្ថិភាពជាងមុន និងក្នុងតម្លៃកាត់បន្ថយ។
បន្តនាំមុខការប្រកួតប្រជែងជាមួយនឹងសេវាកម្មបង្ហោះ WordPress ប្រកបដោយភាពច្នៃប្រឌិតរបស់ 1Byte ។ ផែនការដែលសំបូរទៅដោយលក្ខណៈពិសេសរបស់យើង និងភាពជឿជាក់ដែលមិនអាចប្រៀបផ្ទឹមបានធានាថាគេហទំព័ររបស់អ្នកមានភាពលេចធ្លោ និងផ្តល់នូវបទពិសោធន៍អ្នកប្រើប្រាស់ដែលមិនអាចបំភ្លេចបាន។
ក្នុងនាមជាដៃគូ AWS ផ្លូវការ ទំនួលខុសត្រូវចម្បងមួយរបស់យើងគឺជួយអាជីវកម្មក្នុងការធ្វើទំនើបកម្មប្រតិបត្តិការរបស់ពួកគេ និងប្រើប្រាស់ច្រើនបំផុតក្នុងការធ្វើដំណើររបស់ពួកគេទៅកាន់ពពកជាមួយ AWS ។
សន្និដ្ឋាន
វិធីសាស្រ្តទាំងប្រាំខាងលើអាចភ្ជាប់ខ្សែអក្សរនៅក្នុង Python ។ ប្រើសញ្ញា + សម្រាប់ការរួមផ្សំរហ័សនៃខ្សែមួយចំនួន។ វាងាយស្រួល និងច្បាស់លាស់ ប៉ុន្តែប្រហែលជាគ្មានប្រសិទ្ធភាពទេ ប្រសិនបើប្រើច្រើនពេកនៅក្នុងរង្វិលជុំ។ សម្រាប់ការចូលរួមក្នុងបញ្ជី ឬខ្សែអក្សរជាច្រើន វិធីសាស្ត្រ join() គឺល្អបំផុត៖ វាមានល្បឿនលឿន និងប្រើអង្គចងចាំតិច។ នៅពេលបង្កើតខ្សែអក្សរជាមួយអថេរ f-strings របស់ Python 3 គឺសង្ខេប និងលឿន។ វិធីសាស្ត្រ .format() ដំណើរការល្អផងដែរ ជាពិសេសប្រសិនបើអ្នកត្រូវការមុខងារធ្វើទ្រង់ទ្រាយកម្រិតខ្ពស់ ទោះបីជាវាយឺតជាងបន្តិចក៏ដោយ។ ប្រតិបត្តិករ % គឺជារចនាប័ទ្មចាស់៖ វានៅតែដំណើរការសម្រាប់ការផ្សំខ្សែអក្សរ និងការធ្វើទ្រង់ទ្រាយ ប៉ុន្តែ f-strings ឬ format() ជាទូទៅត្រូវបានគេពេញចិត្តឥឡូវនេះ។
ការចំណាយដ៏សំខាន់៖ ទៅ python ភ្ជាប់ខ្សែអក្សរអ្នកអភិវឌ្ឍន៍មានជម្រើសជាច្រើន៖
- ប្រើ + សម្រាប់ខ្សែអក្សរ ឬករណីសាមញ្ញមួយចំនួន (ឧទាហរណ៍ “ជំរាបសួរ” + “ពិភពលោក”)។
- ប្រើ “separator”.join(list_of_strings) ដើម្បីបញ្ចូលគ្នានូវខ្សែអក្សរជាច្រើនប្រកបដោយប្រសិទ្ធភាព។
- ប្រើ f-strings (f”…{var}…”) សម្រាប់ការបញ្ចូលអថេរច្បាស់លាស់ និងរហ័ស។
- ប្រើ str.format() នៅពេលដែលអ្នកត្រូវការថាមពលទ្រង់ទ្រាយរបស់វា (ឧ. ទ្រនាប់ ទម្រង់លេខ)។
- ប្រតិបត្តិករ % គឺជាវិធីចាស់។ វានៅតែភ្ជាប់គ្នា ប៉ុន្តែភាគច្រើនត្រូវបានជំនួសដោយ f-strings និង format()។
វិធីសាស្រ្តនីមួយៗមានកន្លែងរបស់វា។ ដោយដឹងពីបច្ចេកទេសទាំងប្រាំនេះ អ្នកអភិវឌ្ឍន៍ Python អាចជ្រើសរើសវិធីដែលសមស្រប និងមានប្រសិទ្ធភាពបំផុតក្នុងការផ្សំអត្ថបទសម្រាប់គម្រោងណាមួយ។ ដកស្រង់ ការបង្រៀនថ្មីៗ និងការណែនាំអំពីរចនាប័ទ្ម ធានាថាអនុសាសន៍ទាំងនេះត្រូវនឹងការអនុវត្តល្អបំផុតបច្ចុប្បន្ននិងការរកឃើញការអនុវត្ត។