පයිතන්හි නූලක උපස්ථරයක් ලබා ගන්නේ කෙසේද?

තුන්වන අක්ෂරයේ සිට නූල් අවසානය දක්වා නව නූලක් ලබා ගැනීමට පයිතන්හි නූලක් උපස්ථර කිරීමට ක්‍රමයක් තිබේද?

සමහර විට කැමතිද myString[2:end]?

දෙවන කොටස හැර යාමෙන් අදහස් කරන්නේ 'අවසානය දක්වා' සහ ඔබ පළමු කොටස හැර ගියහොත් එය ආරම්භයේ සිටම ආරම්භ වේද?

>>> x = "Hello World!"
>>> x[2:]
'llo World!'
>>> x[:2]
'He'
>>> x[:-2]
'Hello Worl'
>>> x[-2:]
'd!'
>>> x[2:-2]
'llo Worl'

පයිතන් මෙම සංකල්පය "පෙති කැපීම" ලෙස හඳුන්වන අතර එය හුදෙක් නූල් වලට වඩා වැඩ කරයි. සවිස්තරාත්මක හැඳින්වීමක් සඳහා මෙහි බලන්න .

වෙන කිසිවෙකු සඳහන් කර නැති පරිදි සම්පූර්ණත්වය සඳහා. අරාව පෙත්තකට තුන්වන පරාමිතිය පියවරකි. එබැවින් නූලක් ආපසු හැරවීම තරම් සරල ය:

some_string[::-1]

නැතහොත් විකල්ප අක්ෂර තෝරා ගැනීම වනුයේ:

"H-e-l-l-o- -W-o-r-l-d"[::2] # outputs "Hello World"

නූල් හරහා ඉදිරියට හා පසුපසට යාමට ඇති හැකියාව ආරම්භයේ හෝ අවසානයේ සිට පෙත්තක් පෙළගැස්වීමේ හැකියාව සමඟ අනුකූල වේ.

Substr () සාමාන්‍යයෙන් (එනම් PHP සහ Perl) මේ ආකාරයට ක්‍රියා කරයි:

s = Substr(s, beginning, LENGTH)

එබැවින් පරාමිතීන් beginningසහ LENGTH.

නමුත් පයිතන්ගේ හැසිරීම වෙනස් ය; එය ආරම්භය සහ END (!) ට පසුව එකක් අපේක්ෂා කරයි. ආරම්භකයින්ට මෙය හඳුනා ගැනීම අපහසුය. එබැවින් Substr (s, begin, LENGTH) සඳහා නිවැරදි ආදේශනය වේ

s = s[ beginning : beginning + LENGTH]

මෙය සාක්ෂාත් කර ගැනීම සඳහා පොදු ක්‍රමයක් වන්නේ නූල් කැපීමයි.

MyString[a:b] ඔබට දර්ශකයේ සිට (ආ - 1) දක්වා උපස්ථරයක් ලබා දේ.

එක් උදාහරණයක් මෙහි නැති බව පෙනේ: සම්පූර්ණ (නොගැඹුරු) පිටපත.

>>> x = "Hello World!"
>>> x
'Hello World!'
>>> x[:]
'Hello World!'
>>> x==x[:]
True
>>>

අනුක්‍රමික වර්ගවල පිටපතක් නිර්මාණය කිරීම සඳහා මෙය පොදු මෝඩකමකි (අභ්‍යන්තර නූල් නොවේ) , [:]. නොගැඹුරු ලැයිස්තුවක් පිටපත් කරයි, පැහැදිලි හේතුවක් නොමැතිව භාවිතා කරන පයිතන් ලැයිස්තු පෙති සින්ටැක්ස් බලන්න .

3 වන අක්‍ෂරයේ සිට නූල් අවසානය දක්වා නව නූලක් ලබා ගැනීම සඳහා පයිතන්හි නූලක් උපස්ථර කිරීමට ක්‍රමයක් තිබේද?

සමහර විට කැමතිද myString[2:end]?

ඔව්, නියත සිංගල්ටන් සඳහා නම, හෝ බන්ධනය කළහොත් මෙය සැබවින්ම ක්‍රියාත්මක වේ :endNone

>>> end = None
>>> myString = '1234567890'
>>> myString[2:end]
'34567890'

පෙති අංකනයට වැදගත් තර්ක 3 ක් ඇත:

• ආරම්භ කරන්න
• නවත්වන්න
• පියවර

ලබා නොදෙන විට ඒවායේ පැහැර හැරීම් වේ None- නමුත් අපට ඒවා පැහැදිලිව සම්මත කළ හැකිය:

>>> stop = step = None
>>> start = 2
>>> myString[start:stop:step]
'34567890'

දෙවන කොටස හැර යාමෙන් අදහස් කරන්නේ 'අවසානය දක්වා' නම්, ඔබ පළමු කොටස හැර ගියහොත් එය ආරම්භයේ සිටම ආරම්භ වේද?

ඔව්, උදාහරණයක් ලෙස:

>>> start = None
>>> stop = 2
>>> myString[start:stop:step]
'12'

අපි පෙත්තෙහි ආරම්භය ඇතුළත් කරන බව සලකන්න, නමුත් අපි ඉහළට යන්නේ මිස නැවත්වීමට නොවේ.

පියවර වන විට None, පෙරනිමියෙන් පෙත්ත 1පියවර සඳහා භාවිතා කරයි . ඔබ නිෂේධනීය පූර්ණ සංඛ්‍යාවක් සමඟ පියවර තැබුවහොත්, පයිතන් අවසානයේ සිට ආරම්භය දක්වා යාමට තරම් බුද්ධිමත් ය.

>>> myString[::-1]
'0987654321'

පෙති අංකනය ප්‍රශ්නයට පැහැදිලි කිරීම සඳහා මගේ පිළිතුරෙන් මම පෙති අංකනය ඉතා විස්තරාත්මකව පැහැදිලි කරමි.

"අවසානය" හැර ඔබ එය එතනම ලබාගෙන ඇත. එය පෙති අංකනය ලෙස හැඳින්වේ. ඔබේ උදාහරණය කියවිය යුතුය:

new_sub_string = myString[2:]

ඔබ දෙවන පරාමිතිය අතහැර දැමුවහොත් එය ව්‍යංගයෙන් නූල්වල අවසානය වේ.

සාකච්ඡාවට කරුණු දෙකක් එක් කිරීමට මම කැමතියි:

1. None"ආරම්භයේ සිට" හෝ "අවසානය දක්වා" සඳහන් කිරීමට ඔබට හිස් අවකාශයක් වෙනුවට භාවිතා කළ හැකිය :

   'abcde'[2:None] == 'abcde'[2:] == 'cde'

   මෙය තර්කයක් ලෙස හිස් ඉඩක් ලබා දිය නොහැකි කාර්යයන් සඳහා විශේෂයෙන් උපකාරී වේ:

   def substring(s, start, end):
       """Remove `start` characters from the beginning and `end` 
       characters from the end of string `s`.
   
       Examples
       --------
       >>> substring('abcde', 0, 3)
       'abc'
       >>> substring('abcde', 1, None)
       'bcde'
       """
       return s[start:end]
   

2. පයිතන් පෙති වස්තු ඇත:

   idx = slice(2, None)
   'abcde'[idx] == 'abcde'[2:] == 'cde'
   

MyString හි ගිණුම් අංකයක් ඕෆ්සෙට් 6 සිට ආරම්භ වී දිග 9 ක් තිබේ නම්, ඔබට ගිණුම් අංකය මේ ආකාරයෙන් උකහා ගත හැකිය : acct = myString[6:][:9].

OP එය පිළිගන්නේ නම්, ඔවුන්ට පර්යේෂණාත්මක ආකාරයකින් උත්සාහ කිරීමට අවශ්‍ය විය හැකිය

myString[2:][:999999]

එය ක්‍රියාත්මක වේ - කිසිදු දෝෂයක් මතු නොවන අතර පෙරනිමි 'නූල් පෑඩින්' සිදු නොවේ.

සමහර විට මට එය මග හැරී ඇත, නමුත් විචල්‍යයන් මෙහි තවදුරටත් සාකච්ඡා නොකිරීම නිසා මුල් ප්‍රශ්නයට (ප්‍රශ්න) මෙම පිටුවේ සම්පූර්ණ පිළිතුරක් මට සොයාගත නොහැකි විය. ඒ නිසා මට දිගටම සෙවීමට සිදු විය.

මට තවම අදහස් දැක්වීමට අවසර නොමැති බැවින්, මගේ නිගමනය මෙහි එක් කිරීමට මට ඉඩ දෙන්න. මෙම පිටුවට පිවිසීමේදී මම ඒ ගැන පමණක් උනන්දු නොවූ බව මට විශ්වාසයි:

 >>>myString = 'Hello World'
 >>>end = 5

 >>>myString[2:end]
 'llo'

ඔබ පළමු කොටස අතහැර ගියහොත් ඔබට ලැබෙනු ඇත

 >>>myString[:end]
 'Hello' 

ඔබ හැර ගියහොත්: මැදදී ඔබට සරලම උපස්ථරය ලැබුණි, එය 5 වන අක්‍ෂරය වනු ඇත (0 සිට ආරම්භ වන ගණනය කරන්න, එබැවින් එය මෙම අවස්ථාවේ හිස් ය):

 >>>myString[end]
 ' '

හොඳයි, මට පීඑච්පී පිටපතක් පයිතන් වෙත පරිවර්තනය කිරීමට අවශ්‍ය තත්වයක් ඇති වූ අතර, එහි බොහෝ භාවිතයන් තිබුණි substr(string, beginning, LENGTH).
මම පයිතන් තෝරා ගත්තා නම් මට අවසාන දර්ශක ගොඩක්string[beginning:end] ගණනය කිරීමට සිදුවේ , එබැවින් භාවිතා කිරීමට පහසුම ක්‍රමය නම් , එය මට බොහෝ කරදර ඉතිරි කළේය.string[beginning:][:length]

දෘ c කේත දර්ශක භාවිතා කිරීම අවුල් සහගත විය හැකිය.

එය වළක්වා ගැනීම සඳහා, පයිතන් විසින් සාදන ලද වස්තුවක් ඉදිරිපත් slice()කරයි.

string = "my company has 1000$ on profit, but I lost 500$ gambling."

අපිට දැනගන්න ඕන නම් මම කොපමණ මුදල් ඉතුරු කළාද කියලා.

සාමාන්‍ය විසඳුම:

final = int(string[15:19]) - int(string[43:46])
print(final)
>>>500

පෙති භාවිතා කිරීම:

EARNINGS = slice(15, 19)
LOSSES = slice(43, 46)
final = int(string[EARNINGS]) - int(string[LOSSES])
print(final)
>>>500

පෙත්තක් භාවිතා කිරීමෙන් ඔබට කියවීමේ හැකියාව ලැබේ.

පයිතන්හි සුචිගත කිරීමේ හා වෙනස් කිරීමේ විවිධ ක්‍රම තිබේ. ඔබ එය උපස්ථර කිරීමට උත්සාහ කරන අතරතුර එය නූල් මත ආලේප කළ හැකිය.

string = 'Hello world'
string[A:B:C]

A යනු ආරම්භයයි, B අවසානයේ B සහ C ඔබ පියවරයි

string[0:]

පළමු අක්‍ෂරයෙන් වම් strnig [-len (string):] දකුණේ පළමු අක්‍ෂරයෙන්

string[0:len(string)]

මුළු නූල සඳහාම ඔබට ඒ හා සමානව ඉදිරියට යා හැකිය

string[0:10:2]

මෙය වමේ සිට අක්ෂර දෙකක් උඩින් පනින්න