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

මට නම්, මෙම අංකනය ටිකක් ගන්න අවශ්‍යයි.

එය අතිශයින්ම බලවත් බව පෙනේ, නමුත් මගේ හිස ඒ වටා එතරම් ප්‍රමාණවත් නැත.

ඇත්තෙන්ම එය ඉතා සරල ය:

a[start:stop]  # items start through stop-1
a[start:]      # items start through the rest of the array
a[:stop]       # items from the beginning through stop-1
a[:]           # a copy of the whole array

ද පවතී stepඉහත සඳහන් කළ ඕනෑම සමග භාවිතා කල හැකි වන අගය:

a[start:stop:step] # start through not past stop, by step

මතක තබා ගත යුතු ප්‍රධාන කරුණ නම් තෝරාගත් පෙත්තක නොමැති:stop පළමු අගය අගය නියෝජනය කිරීමයි . එබැවින්, තෝරාගත් මූලද්‍රව්‍ය ගණන අතර වෙනස සහ ( 1 නම් , පෙරනිමිය).stopstartstep

අනෙක් ලක්ෂණය නම් startහෝ negative ණ සංඛ්‍යාවක් stopවිය හැකිය , එයින් අදහස් වන්නේ එය ආරම්භය වෙනුවට අරාවේ කෙළවරේ සිට ගණනය කිරීමයි. ඒ නිසා:

a[-1]    # last item in the array
a[-2:]   # last two items in the array
a[:-2]   # everything except the last two items

ඒ හා සමානව, stepnegative ණ සංඛ්‍යාවක් විය හැකිය:

a[::-1]    # all items in the array, reversed
a[1::-1]   # the first two items, reversed
a[:-3:-1]  # the last two items, reversed
a[-3::-1]  # everything except the last two items, reversed

ඔබ ඉල්ලන ප්‍රමාණයට වඩා අඩු අයිතම තිබේ නම් පයිතන් ක්‍රමලේඛකයාට කරුණාවන්ත වේ. උදාහරණයක් ලෙස, ඔබ ඉල්ලනවා නම් a[:-2]හා aඑක් අංගයක් අඩංගු, ඔබට ඒ වෙනුවට දෝෂයක් ක හිස් ලැයිස්තුවක් ලබා ගන්න. සමහර විට ඔබ දෝෂයට වැඩි කැමැත්තක් දක්වනු ඇත, එබැවින් මෙය සිදුවිය හැකි බව ඔබ දැන සිටිය යුතුය.

slice()වස්තුවට සම්බන්ධතාවය

පෙති කපන ක්‍රියාකරු []සැබවින්ම ඉහත කේතයේ අංකනය slice()භාවිතා කරමින් වස්තුවක් සමඟ භාවිතා කරයි :(එය වලංගු වන්නේ ඇතුළත පමණි []), එනම්:

a[start:stop:step]

සමාන වේ:

a[slice(start, stop, step)]

පෙති වස්තූන් ද තර්ක ගණන අනුව තරමක් වෙනස් ලෙස හැසිරේ, ඒ හා සමානව range(), එනම් දෙකම slice(stop)සහ slice(start, stop[, step])සහාය දක්වයි. දී ඇති තර්කයක් සඳහන් කිරීම මඟ හැරීම සඳහා, යමෙකු භාවිතා කළ හැකිය None, එවිට උදා a[start:]. සමාන a[slice(start, None)]හෝ a[::-1]සමාන වේ a[slice(None, None, -1)].

කරන අතර :පරිච්ඡේදය අංකනය සරල යසිකා සඳහා ඉතා ප්රයෝජනවත් වන අතර, පැහැදිලි ලෙසම භාවිතා slice()වස්තූන් විසින් යසිකා රාහුබද්ධ කි්රයාමාර්ගික පරම්පරාව වඩාත් සරලවන.

මෙම පිඹුරා නිබන්ධන ඒ ගැන සාකච්ඡා (අනුචලන ටිකක් අඩු ඔබ විසින් යසිකා රාහුබද්ධ ගැන කොටසක් කිරීමට ලබා තෙක්).

පෙති ක්‍රියා කරන ආකාරය මතක තබා ගැනීමට ASCII චිත්‍ර සටහන ද උපකාරී වේ:

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

කෙසේ පෙති වැඩ මතක තබා ගැනීමට එක් ක්රමයක් යොමු ලෙස දර්ශක හිතන්න වේ අතර පළමු අක්ෂරය වම් අද්දර 0 ගණන් සමග එවිට වැලක් අවසන් අක්ෂරය ඇති අයිතිය අද්දර, චරිත n චරිත දර්ශකය n .

ව්‍යාකරණ මඟින් අවසර දී ඇති හැකියාවන් ගණනය කිරීම:

>>> seq[:]                # [seq[0],   seq[1],          ..., seq[-1]    ]
>>> seq[low:]             # [seq[low], seq[low+1],      ..., seq[-1]    ]
>>> seq[:high]            # [seq[0],   seq[1],          ..., seq[high-1]]
>>> seq[low:high]         # [seq[low], seq[low+1],      ..., seq[high-1]]
>>> seq[::stride]         # [seq[0],   seq[stride],     ..., seq[-1]    ]
>>> seq[low::stride]      # [seq[low], seq[low+stride], ..., seq[-1]    ]
>>> seq[:high:stride]     # [seq[0],   seq[stride],     ..., seq[high-1]]
>>> seq[low:high:stride]  # [seq[low], seq[low+stride], ..., seq[high-1]]

ඇත්ත වශයෙන්ම, එසේ නම් (high-low)%stride != 0, අවසාන ලක්ෂ්‍යය වඩා ටිකක් අඩු වනු ඇත high-1.

strideNegative ණාත්මක නම් , අපි ගණන් කරන බැවින් ඇණවුම ටිකක් වෙනස් වේ:

>>> seq[::-stride]        # [seq[-1],   seq[-1-stride],   ..., seq[0]    ]
>>> seq[high::-stride]    # [seq[high], seq[high-stride], ..., seq[0]    ]
>>> seq[:low:-stride]     # [seq[-1],   seq[-1-stride],   ..., seq[low+1]]
>>> seq[high:low:-stride] # [seq[high], seq[high-stride], ..., seq[low+1]]

විස්තාරණය කරන ලද පෙති (කොමා සහ ඉලිප්සාකාර සමඟ) බොහෝ විට භාවිතා කරනුයේ විශේෂ දත්ත ව්‍යුහයන් (NumPy වැනි) පමණි; මූලික අනුපිළිවෙල ඒවාට සහාය නොදක්වයි.

>>> class slicee:
...     def __getitem__(self, item):
...         return repr(item)
...
>>> slicee()[0, 1:2, ::5, ...]
'(0, slice(1, 2, None), slice(None, None, 5), Ellipsis)'

ඉහත පිළිතුරු පෙති පැවරීම ගැන සාකච්ඡා නොකරයි. පෙති පැවරුම අවබෝධ කර ගැනීම සඳහා, ASCII කලාවට තවත් සංකල්පයක් එක් කිරීම ප්‍රයෝජනවත් වේ:

                +---+---+---+---+---+---+
                | P | y | t | h | o | n |
                +---+---+---+---+---+---+
Slice position: 0   1   2   3   4   5   6
Index position:   0   1   2   3   4   5

>>> p = ['P','y','t','h','o','n']
# Why the two sets of numbers:
# indexing gives items, not lists
>>> p[0]
 'P'
>>> p[5]
 'n'

# Slicing gives lists
>>> p[0:1]
 ['P']
>>> p[0:2]
 ['P','y']

එක් ur ෂධයක් නම්, ශුන්‍යයේ සිට n දක්වා පෙත්තක් සඳහා සිතන්න: "ශුන්‍යය ආරම්භයයි, ආරම්භයේ සිට ආරම්භ කර ලැයිස්තුවේ අයිතම n ගන්න".

>>> p[5] # the last of six items, indexed from zero
 'n'
>>> p[0:5] # does NOT include the last item!
 ['P','y','t','h','o']
>>> p[0:6] # not p[0:5]!!!
 ['P','y','t','h','o','n']

"

>>> p[0:4] # Start at the beginning and count out 4 items
 ['P','y','t','h']
>>> p[1:4] # Take one item off the front
 ['y','t','h']
>>> p[2:4] # Take two items off the front
 ['t','h']
# etc.

පෙති පැවරුමේ පළමු රීතිය නම්, පෙති කැපීම මඟින් ලැයිස්තුවක් ලබා දෙන බැවින් , පෙති පැවරුමට ලැයිස්තුවක් අවශ්‍ය වේ (හෝ වෙනත් නැවත කළ හැකි):

>>> p[2:3]
 ['t']
>>> p[2:3] = ['T']
>>> p
 ['P','y','T','h','o','n']
>>> p[2:3] = 't'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only assign an iterable

ස්ලයිස් පැවරුමේ දෙවන රීතිය නම්, ඔබට ඉහත දැකිය හැකි පරිදි, ලැයිස්තුවේ ඕනෑම කොටසක් ස්ලයිස් සුචිගත කිරීම මඟින් ආපසු ලබා දෙනු ලැබේ, එය පෙති පැවරුමෙන් වෙනස් වන එකම කොටසයි:

>>> p[2:4]
 ['T','h']
>>> p[2:4] = ['t','r']
>>> p
 ['P','y','t','r','o','n']

පෙති පැවරුමේ තුන්වන රීතිය නම්, පවරා ඇති ලැයිස්තුවට (නැවත ක්‍රියාත්මක කළ හැකි) එකම දිගක් තිබිය යුතු නැත; සුචිගත කරන ලද පෙත්ත සරලව කපා කොටා ඇති ඕනෑම දෙයක් සමූහ වශයෙන් ප්‍රතිස්ථාපනය කරයි:

>>> p = ['P','y','t','h','o','n'] # Start over
>>> p[2:4] = ['s','p','a','m']
>>> p
 ['P','y','s','p','a','m','o','n']

පුරුදු වීමට ඇති උපායශීලී කොටස වන්නේ හිස් පෙති පැවරීමයි. හියුරිස්ටික් 1 සහ 2 භාවිතා කරමින් හිස් පෙත්තක් සුචිගත කිරීම සඳහා ඔබේ හිස ලබා ගැනීම පහසුය :

>>> p = ['P','y','t','h','o','n']
>>> p[0:4]
 ['P','y','t','h']
>>> p[1:4]
 ['y','t','h']
>>> p[2:4]
 ['t','h']
>>> p[3:4]
 ['h']
>>> p[4:4]
 []

ඔබ එය දුටු පසු, හිස් පෙත්තකට පෙත්තක් පැවරීම ද අර්ථවත් කරයි:

>>> p = ['P','y','t','h','o','n']
>>> p[2:4] = ['x','y'] # Assigned list is same length as slice
>>> p
 ['P','y','x','y','o','n'] # Result is same length
>>> p = ['P','y','t','h','o','n']
>>> p[3:4] = ['x','y'] # Assigned list is longer than slice
>>> p
 ['P','y','t','x','y','o','n'] # The result is longer
>>> p = ['P','y','t','h','o','n']
>>> p[4:4] = ['x','y']
>>> p
 ['P','y','t','h','x','y','o','n'] # The result is longer still

අපි පෙත්තෙහි දෙවන අංකය (4) වෙනස් නොකරන බැවින්, ඇතුළත් කළ අයිතම හිස් හිස් පෙත්තකට අප පැවරූ විට පවා සෑම විටම 'ඕ' ට එරෙහිව නැගී සිටිනු ඇත. එබැවින් හිස් පෙති පැවරුම සඳහා පිහිටීම හිස් නොවන පෙති පැවරුම් සඳහා ස්ථානවල තාර්කික දිගුවයි.

මඳක් උපස්ථ කිරීම, ඔබ අපේ පෙරහැර සමඟ පෙත්ත ආරම්භය ගණන් කරන විට කුමක් සිදුවේද?

>>> p = ['P','y','t','h','o','n']
>>> p[0:4]
 ['P','y','t','h']
>>> p[1:4]
 ['y','t','h']
>>> p[2:4]
 ['t','h']
>>> p[3:4]
 ['h']
>>> p[4:4]
 []
>>> p[5:4]
 []
>>> p[6:4]
 []

පෙති කැපීමෙන්, ඔබ අවසන් වූ පසු, ඔබ ඉවරයි; එය පසුපසට කැපීම ආරම්භ නොකරයි. පයිතන් හි දී ඔබ negative ණ සංඛ්‍යාවක් භාවිතා කිරීමෙන් ඒවා පැහැදිලිව ඉල්ලා සිටියොත් මිස ඔබට negative ණාත්මක පියවරක් නොලැබේ.

>>> p[5:3:-1]
 ['n','o']

“ඔබ අවසන් වූ පසු, ඔබ ඉවරයි” රීතියට අමුතු ප්‍රතිවිපාක ඇත:

>>> p[4:4]
 []
>>> p[5:4]
 []
>>> p[6:4]
 []
>>> p[6]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

ඇත්ත වශයෙන්ම, සුචිගත කිරීම හා සසඳන විට, පයිතන් කැපීම විකාර සහගත දෝෂ සහිත ය:

>>> p[100:200]
 []
>>> p[int(2e99):int(1e99)]
 []

මෙය සමහර විට ප්‍රයෝජනවත් විය හැකි නමුත් එය තරමක් අමුතු හැසිරීමට ද හේතු විය හැකිය:

>>> p
 ['P', 'y', 't', 'h', 'o', 'n']
>>> p[int(2e99):int(1e99)] = ['p','o','w','e','r']
>>> p
 ['P', 'y', 't', 'h', 'o', 'n', 'p', 'o', 'w', 'e', 'r']

ඔබගේ යෙදුම මත පදනම්ව, එය ... හෝ නොවිය හැකිය ... ඔබ එහි බලාපොරොත්තුවෙන් සිටි දේ විය හැකිය!

පහත දැක්වෙන්නේ මගේ මුල් පිළිතුරේ පෙළයි. එය බොහෝ දෙනෙකුට ප්‍රයෝජනවත් වී ඇති බැවින් එය මකා දැමීමට මට අවශ්‍ය නොවීය.

>>> r=[1,2,3,4]
>>> r[1:1]
[]
>>> r[1:1]=[9,8]
>>> r
[1, 9, 8, 2, 3, 4]
>>> r[1:1]=['blah']
>>> r
[1, 'blah', 9, 8, 2, 3, 4]

පෙති කැපීම සහ සුචිගත කිරීම අතර වෙනස ද මෙය පැහැදිලි කරයි.

පයිතන්ගේ පෙති අංකනය පැහැදිලි කරන්න

කෙටියෙන් කියතොත්, කොලෝනය ( :) යටකුරක් අංකනය ( subscriptable[subscriptarg]) පසුබිම පෙත්තක් අංකනය - විකල්ප තර්ක ඇති, start, stop, step:

sliceable[start:stop:step]

පයිතන් කැපීම යනු ඔබේ දත්තවල කොටස් ක්‍රමවත් ලෙස ප්‍රවේශ කිරීමට පරිගණකමය වශයෙන් වේගවත් ක්‍රමයකි. මගේ මතය අනුව, අතරමැදි පයිතන් ක්‍රමලේඛකයෙකු වීමට නම්, එය හුරුපුරුදු විය යුතු භාෂාවේ එක් අංගයකි.

වැදගත් අර්ථ දැක්වීම්

ආරම්භ කිරීමට, අපි පද කිහිපයක් නිර්වචනය කරමු:

ආරම්භය: පෙත්තෙහි ආරම්භක දර්ශකය, එය නැවතුමට සමාන නොවන්නේ නම්, මෙම දර්ශකයේ මූලද්‍රව්‍යය ඇතුළත් වේ , පෙරනිමිය 0 දක්වා, එනම් පළමු දර්ශකය. එය negative ණාත්මක නම්, එයින් අදහස් වන්නේ nඅයිතමයන් අවසානයේ සිට ආරම්භ කිරීමයි.

stop: පෙත්තෙහි අවසන් දර්ශකය, එය එසේ නොවේ මෙම දර්ශකය දී අංගයක් ඇතුළත්, අනු දිග පෙරනිමි පෙති කැපූ කරමින්, අවසන් ඇතුළු දක්වා සහ බව.

පියවර: දර්ශකය වැඩි වන ප්‍රමාණය, පෙරනිමිය 1 දක්වා. එය negative ණ නම්, ඔබ ආපසු හැරවිය හැකි ප්‍රමාණයට වඩා පෙති කපයි.

සුචිගත කිරීම ක්‍රියා කරන ආකාරය

ඔබට මෙම ඕනෑම ධනාත්මක හෝ negative ණ සංඛ්‍යාවක් සෑදිය හැකිය. ධනාත්මක සංඛ්‍යා වල අර්ථය සරල ය, නමුත් negative ණ සංඛ්‍යා සඳහා, පයිතන්හි දර්ශක මෙන්, ආරම්භය සහ නැවතුම සඳහා ඔබ අවසානයේ සිට පසුපසට ගණන් කරන අතර පියවර සඳහා ඔබ ඔබේ දර්ශකය අඩු කරයි. මෙම උදාහරණය ප්‍රලේඛනයේ නිබන්ධනයෙන් , නමුත් එක් එක් දර්ශකය යොමු කරන අනුපිළිවෙලෙහි ඇති අයිතමය දැක්වීමට මම එය තරමක් වෙනස් කර ඇත:

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
   0   1   2   3   4   5 
  -6  -5  -4  -3  -2  -1

පෙති කැපීම ක්‍රියා කරන ආකාරය

පෙති අංකනය එයට අනුබල දෙන අනුක්‍රමයක් සමඟ භාවිතා කිරීම සඳහා, ඔබ අනුක්‍රමය අනුගමනය කරන හතරැස් වරහන් තුළ අවම වශයෙන් එක් මහා බඩවැලක්වත් ඇතුළත් කළ යුතුය ( පයිතන් දත්ත ආකෘතියට අනුව අනුක්‍රමයේ ක්‍රමය සැබවින්ම ක්‍රියාත්මක කරයි__getitem__ .)

පෙති අංකනය මේ ආකාරයට ක්‍රියා කරයි:

sequence[start:stop:step]

ආරම්භය , නැවැත්වීම සහ පියවර සඳහා පෙරනිමි ඇති බව මතක තබා ගන්න , එබැවින් පෙරනිමි වෙත ප්‍රවේශ වීම සඳහා, තර්කය අත්හරින්න.

ලැයිස්තුවකින් අවසාන මූලද්‍රව්‍ය නවය ලබා ගැනීම සඳහා ස්ලයිස් අංකනය (හෝ ඊට අනුබල දෙන වෙනත් අනුක්‍රමයක්, නූලක් වැනි) මේ වගේ වනු ඇත:

my_list[-9:]

මෙය දුටු විට, වරහන් වල ඇති කොටස "9 සිට අවසානය දක්වා" ලෙස කියවමි. (ඇත්ත වශයෙන්ම, මම එය මානසිකව "-9, මත" ලෙස නම් කරමි)

පැහැදිලි කිරීම:

සම්පූර්ණ අංකනය වේ

my_list[-9:None:None]

සහ පෙරනිමි ආදේශ කිරීම සඳහා (ඇත්ත වශයෙන්ම stepnegative ණාත්මක වන විට , stopපෙරනිමිය වේ -len(my_list) - 1, එබැවින් Noneනැවැත්වීම යන්නෙන් අදහස් කරන්නේ එය කුමන අවසන් පියවරක් කරා යනවාද යන්නයි):

my_list[-9:len(my_list):1]

මෙම මහා අන්ත්රය , :, Python කියන දේ ඔබ එය පෙත්තක් නොව සාමාන්ය දර්ශකය දෙනවා ඇත. පයිතන් 2 හි නොගැඹුරු පිටපතක් සෑදීමේ මුග්ධ ක්‍රමය වන්නේ එබැවිනි

list_copy = sequence[:]

ඒවා ඉවත් කිරීම පහත පරිදි වේ:

del my_list[:]

(පයිතන් 3 ට a list.copyසහlist.clear ක්‍රමයක් ක්‍රමයක් ලැබේ.)

stepNegative ණාත්මක වන විට , startසහ සඳහා පෙරනිමිstop වෙනස්

පෙරනිමියෙන්, stepතර්කය හිස් වූ විට (හෝ None), එය පවරනු ලැබේ+1 .

නමුත් ඔබට negative ණ නිඛිලයකින් සමත් විය හැකි අතර, ලැයිස්තුව (හෝ වෙනත් බොහෝ සම්මත පෙති) අවසානයේ සිට ආරම්භය දක්වා කපා දමනු ලැබේ.

මේ අනුව negative ණ පෙත්තක් startසහ සඳහා පෙරනිමි වෙනස් කරයිstop !

මූලාශ්රයේ මෙය තහවුරු කිරීම

මූලාශ්‍රය මෙන්ම ලියකියවිලි කියවීමට පරිශීලකයින් දිරිමත් කිරීමට මම කැමතියි. මෙම පෙත්තක් වස්තූන් සඳහා මූල කේතය හා මෙම තර්ක මෙහි හමු වී ඇත . පළමුව අපි stepනිෂේධාත්මකද යන්න තීරණය කරමු :

 step_is_negative = step_sign < 0;

එසේ නම්, පහළ -1 මායිම යන්නෙන් අදහස් වන්නේ අපි ආරම්භය දක්වාම ඇතුළු වන තෙක්ම කැපූ අතර ඉහළ මායිම දිග us ණ 1 වේ, එයින් අදහස් වන්නේ අප අවසානයේ ආරම්භ කිරීමයි. (සටහන මේ වන semantics බව -1ය විවිධ සිට -1පසුගිය අයිතමය පෙන්නුම් පරිශීලකයන් Python දී දර්ශක සමත් විය හැකි.)

if (step_is_negative) {
    lower = PyLong_FromLong(-1L);
    if (lower == NULL)
        goto error;

    upper = PyNumber_Add(length, lower);
    if (upper == NULL)
        goto error;
}

එසේ නොමැතිනම් stepධනාත්මක වන අතර පහළ මායිම ශුන්‍ය වන අතර පෙති කපන ලද ලැයිස්තුවේ දිග (අපි ඉහළට යන නමුත් ඇතුළත් නොවේ).

else {
    lower = _PyLong_Zero;
    Py_INCREF(lower);
    upper = length;
    Py_INCREF(upper);
}

එසේ නම්, අපට සඳහා පෙරනිමි අයදුම් කිරීමට අවශ්ය විය හැක startහා stop- පෙරනිමි පසුව සඳහා startඉහළ බැඳී ලෙස ගණනය කළ විට stepසෘණ:

if (self->start == Py_None) {
    start = step_is_negative ? upper : lower;
    Py_INCREF(start);
}

සහ stop, පහළ සීමාව:

if (self->stop == Py_None) {
    stop = step_is_negative ? lower : upper;
    Py_INCREF(stop);
}

ඔබේ පෙති වලට විස්තරාත්මක නමක් දෙන්න!

පෙත්තක් සෑදීම list.__getitem__ක්‍රමයට යැවීමෙන් වෙන් කිරීම ඔබට ප්‍රයෝජනවත් විය හැකිය ( වර්ග වරහන් කරන්නේ එයයි ). ඔබ එයට අලුත් නොවුනත්, එය ඔබගේ කේතය වඩාත් කියවිය හැකි වන අතර එමඟින් ඔබේ කේතය කියවිය යුතු අනෙක් අයට ඔබ කරන්නේ කුමක්ද යන්න වඩාත් පහසුවෙන් තේරුම් ගත හැකිය.

කෙසේ වෙතත්, ඔබට විචල්‍යයකට කොලෝන් මගින් වෙන් කරන ලද පූර්ණ සංඛ්‍යා කිහිපයක් පැවරිය නොහැක. ඔබ පෙති වස්තුව භාවිතා කළ යුතුය:

last_nine_slice = slice(-9, None)

දෙවන තර්කය, None,, අවශ්ය පළමු තර්කය ලෙස අර්ථ නිරූපණය කෙරෙන නිසා බව startතර්කය එසේ එය වනු ඇත stopතර්කය .

ඔබට පසුව පෙති වස්තුව ඔබේ අනුක්‍රමයට යැවිය හැකිය:

>>> list(range(100))[last_nine_slice]
[91, 92, 93, 94, 95, 96, 97, 98, 99]

පරාසයන් ද පෙති ගැනීම සිත්ගන්නා කරුණකි:

>>> range(100)[last_nine_slice]
range(91, 100)

මතක සලකා බැලීම්:

පයිතන් ලැයිස්තු පෙති මතකයේ නව වස්තූන් නිර්මාණය කරන බැවින්, දැනුවත් විය යුතු තවත් වැදගත් කාර්යයක් වන්නේ itertools.islice. සාමාන්‍යයෙන් ඔබට පෙත්තක් හරහා නැවත කියවීමට අවශ්‍ය වනු ඇත, එය මතකයේ ස්ථිතිකව නිර්මාණය කර නැත. isliceමේ සඳහා පරිපූර්ණයි. වරනයක්, එය සෘණ තර්ක කිරීමට පහසුකම් සපයන්නේ නැත start, stopහෝ step, ඔබ ගණනය දර්ශක අවශ්ය හෝ කල්තියා iterable ආපසු හැරවීමට හැකි ප්රශ්නයක් එසේ නම්.

length = 100
last_nine_iter = itertools.islice(list(range(length)), length-9, None, 1)
list_last_nine = list(last_nine_iter)

සහ දැන්:

>>> list_last_nine
[91, 92, 93, 94, 95, 96, 97, 98, 99]

ලැයිස්තු පෙති පිටපතක් සාදයි යන කාරණය ලැයිස්තු වලම ලක්ෂණයකි. ඔබ පැන්ඩාස් ඩේටා ෆ්‍රේම් වැනි උසස් වස්තු පෙති කපන්නේ නම්, එය මුල් පිටපතක් ලබා ගත හැකි අතර පිටපතක් නොවේ.

පෙති කපන වාක්‍ය ඛණ්ඩය මා දුටු විට මට නොපෙනෙන කරුණු කිහිපයක්:

>>> x = [1,2,3,4,5,6]
>>> x[::-1]
[6,5,4,3,2,1]

අනුපිළිවෙල ආපසු හැරවීමට පහසුම ක්‍රමය!

ඔබට අවශ්‍ය නම්, කිසියම් හේතුවක් නිසා, ප්‍රතිලෝම අනුක්‍රමයේ සෑම දෙවන අයිතමයක්ම:

>>> x = [1,2,3,4,5,6]
>>> x[::-2]
[6,4,2]

පයිතන් 2.7 හි

පයිතන් පෙති කැපීම

[a:b:c]

len = length of string, tuple or list

c -- default is +1. The sign of c indicates forward or backward, absolute value of c indicates steps. Default is forward with step size 1. Positive means forward, negative means backward.

a --  When c is positive or blank, default is 0. When c is negative, default is -1.

b --  When c is positive or blank, default is len. When c is negative, default is -(len+1).

දර්ශක පැවරුම අවබෝධ කර ගැනීම ඉතා වැදගත් ය.

In forward direction, starts at 0 and ends at len-1

In backward direction, starts at -1 and ends at -len

ඔබ [a: b: c] යැයි කියන විට, ඔබ කියන්නේ c (ඉදිරියට හෝ පසුපසට) ලකුණ අනුව, a සිට ආරම්භ කර b හි අවසන් කරන්න (bth දර්ශකයේ මූලද්‍රව්‍යය හැර). ඉහත සුචිගත කිරීමේ රීතිය භාවිතා කර ඔබට මෙම පරාසය තුළ ඇති මූලද්‍රව්‍ය පමණක් සොයාගත හැකි බව මතක තබා ගන්න:

-len, -len+1, -len+2, ..., 0, 1, 2,3,4 , len -1

නමුත් මෙම පරාසය දෙපැත්තෙන්ම අනන්තය:

...,-len -2 ,-len-1,-len, -len+1, -len+2, ..., 0, 1, 2,3,4 , len -1, len, len +1, len+2 , ....

උදාහරණයක් වශයෙන්:

             0    1    2   3    4   5   6   7   8   9   10   11
             a    s    t   r    i   n   g
    -9  -8  -7   -6   -5  -4   -3  -2  -1

ඔබ a, b, සහ c තේරීම ඉහත පරාසය සමඟ අතිච්ඡාදනය වීමට ඉඩ දෙන්නේ නම්, ඉහත, a, b සඳහා නීති භාවිතා කරමින් ඔබට මූලද්‍රව්‍ය සහිත ලැයිස්තුවක් ලැබෙනු ඇත (ගමන් කිරීමේදී ස්පර්ශ වේ) හෝ ඔබට හිස් ලැයිස්තුවක් ලැබෙනු ඇත.

අන්තිම එක: a සහ b සමාන නම් ඔබට හිස් ලැයිස්තුවක් ද ලැබේ:

>>> l1
[2, 3, 4]

>>> l1[:]
[2, 3, 4]

>>> l1[::-1] # a default is -1 , b default is -(len+1)
[4, 3, 2]

>>> l1[:-4:-1] # a default is -1
[4, 3, 2]

>>> l1[:-3:-1] # a default is -1
[4, 3]

>>> l1[::] # c default is +1, so a default is 0, b default is len
[2, 3, 4]

>>> l1[::-1] # c is -1 , so a default is -1 and b default is -(len+1)
[4, 3, 2]


>>> l1[-100:-200:-1] # Interesting
[]

>>> l1[-1:-200:-1] # Interesting
[4, 3, 2]


>>> l1[-1:-1:1]
[]


>>> l1[-1:5:1] # Interesting
[4]


>>> l1[1:-7:1]
[]

>>> l1[1:-7:-1] # Interesting
[3, 2]

>>> l1[:-2:-2] # a default is -1, stop(b) at -2 , step(c) by 2 in reverse direction
[4]

මෙම විශිෂ්ට වගුව http://wiki.python.org/moin/MovingToPythonFromOtherLanguages ​​වෙතින් හමු විය

Python indexes and slices for a six-element list.
Indexes enumerate the elements, slices enumerate the spaces between the elements.

Index from rear:    -6  -5  -4  -3  -2  -1      a=[0,1,2,3,4,5]    a[1:]==[1,2,3,4,5]
Index from front:    0   1   2   3   4   5      len(a)==6          a[:5]==[0,1,2,3,4]
                   +---+---+---+---+---+---+    a[0]==0            a[:-2]==[0,1,2,3]
                   | a | b | c | d | e | f |    a[5]==5            a[1:2]==[1]
                   +---+---+---+---+---+---+    a[-1]==5           a[1:-1]==[1,2,3,4]
Slice from front:  :   1   2   3   4   5   :    a[-2]==4
Slice from rear:   :  -5  -4  -3  -2  -1   :
                                                b=a[:]
                                                b==[0,1,2,3,4,5] (shallow copy of a)

එය ටිකක් භාවිතා කිරීමෙන් පසුව මට වැටහෙනවා සරලම විස්තරය එය හරියටම ලූපයක තර්ක වලට සමාන බව for...

(from:to:step)

ඒවායින් ඕනෑම එකක් අත්‍යවශ්‍ය නොවේ:

(:to:step)
(from::step)
(from:to)

එවිට negative ණාත්මක සුචිගත කිරීම මඟින් ඔබට එය තේරුම් ගැනීමට නූලෙහි දිග the ණ දර්ශකවලට එකතු කළ යුතුය.

මෙය කෙසේ හෝ මට වැඩ කරයි ...

එය ක්‍රියාත්මක වන ආකාරය මතක තබා ගැනීම මට පහසු වන අතර, පසුව මට ඕනෑම නිශ්චිත ආරම්භක / නැවතුම් / පියවර සංයෝජනයක් හඳුනාගත හැකිය.

range()පළමුව තේරුම් ගැනීම උපදේශාත්මක ය :

def range(start=0, stop, step=1):  # Illegal syntax, but that's the effect
    i = start
    while (i < stop if step > 0 else i > stop):
        yield i
        i += step

සිට ආරම්භ කරන්න start, වැඩි කරන්න , stepළඟා නොවන්න stop. හරිම සරලයි.

Negative ණාත්මක පියවර ගැන මතක තබා ගත යුතු දෙය නම් stop, එය ඉහළ හෝ පහළ වේවා සෑම විටම බැහැර කළ අවසානයයි. ඔබට එකම පෙත්තක් ප්‍රතිවිරුද්ධ අනුපිළිවෙලට අවශ්‍ය නම්, ආපසු හැරවීම වෙන වෙනම කිරීම වඩා පිරිසිදු ය: උදා: 'abcde'[1:-2][::-1]වම්පස සිට එක් වර්‍ගයක්, දකුණේ සිට දෙකක්, පසුව ආපසු හරවන්න. (මෙයද බලන්න reversed().)

අනුක්‍රමික පෙති කැපීම සමාන වේ, එය මුලින් negative ණ දර්ශක සාමාන්‍යකරණය කිරීම හැර, එය කිසි විටෙකත් අනුක්‍රමයෙන් පිටතට යා නොහැක:

ටෝඩෝ : පහත කේතයෙහි දෝෂයක් ඇති අතර එය කිසි විටෙකත් අනුක්‍රමයෙන් පිටතට නොයනු ඇත. මම හිතන්නේ මම එය නිවැරදි යැයි සිතුවෙමි, නමුත් එය තේරුම් ගැනීමට අපහසුය.

def this_is_how_slicing_works(seq, start=None, stop=None, step=1):
    if start is None:
        start = (0 if step > 0 else len(seq)-1)
    elif start < 0:
        start += len(seq)
    if not 0 <= start < len(seq):  # clip if still outside bounds
        start = (0 if step > 0 else len(seq)-1)
    if stop is None:
        stop = (len(seq) if step > 0 else -1)  # really -1, not last element
    elif stop < 0:
        stop += len(seq)
    for i in range(start, stop, step):
        if 0 <= i < len(seq):
            yield seq[i]

is Noneවිස්තර ගැන කරදර නොවන්න - මඟ හැරීම startසහ / හෝ stopසෑම විටම ඔබට සම්පූර්ණ අනුක්‍රමය ලබා දීම සඳහා නිවැරදි දේ කරන බව මතක තබා ගන්න .

Negative ණාත්මක දර්ශක සාමාන්‍යකරණය කිරීම මඟින් ආරම්භය සහ / හෝ නැවැත්වීම අවසානයේ සිට ස්වාධීනව ගණනය කිරීමට ඉඩ දෙයි: 'abcde'[1:-2] == 'abcde'[1:3] == 'bc'නොතකා range(1,-2) == []. සාමාන්‍යකරණය සමහර විට "දිග මොඩියුලය" ලෙස සැලකේ, නමුත් එය දිග එක් වරක් පමණක් එකතු කරන බව සලකන්න: උදා: 'abcde'[-53:42]සම්පූර්ණ නූල පමණි.

මම "මූලද්‍රව්‍ය අතර දර්ශක ලකුණු" මා ගැන සිතීමේ ක්‍රමය භාවිතා කරමි, නමුත් එය විස්තර කිරීමේ එක් ක්‍රමයක් සමහර විට අනෙක් අයට එය ලබා ගැනීමට උපකාරී වේ:

mylist[X:Y]

X යනු ඔබට අවශ්‍ය පළමු මූලද්‍රව්‍යයේ දර්ශකයයි.
Y යනු ඔබට අවශ්‍ය නොවන පළමු මූලද්‍රව්‍යයේ දර්ශකයයි .

Index:
      ------------>
  0   1   2   3   4
+---+---+---+---+---+
| a | b | c | d | e |
+---+---+---+---+---+
  0  -4  -3  -2  -1
      <------------

Slice:
    <---------------|
|--------------->
:   1   2   3   4   :
+---+---+---+---+---+
| a | b | c | d | e |
+---+---+---+---+---+
:  -4  -3  -2  -1   :
|--------------->
    <---------------|

පයිතන් හි ලැයිස්තුව ආදර්ශනය කිරීමට මෙය ඔබට උපකාරී වනු ඇතැයි මම බලාපොරොත්තු වෙමි.

යොමුව: http://wiki.python.org/moin/MovingToPythonFromOtherLanguages

පයිතන් පෙති කැපීමේ අංකනය:

a[start:end:step]

• සඳහා startසහ end, ඍණ අගයන් අනුක්රමයේ අවසන් සාපේක්ෂව වීම ලෙස අර්ථ ඇත.
• සඳහා ධනාත්මක දර්ශක පසුend පිහිටීම දක්වයිඇතුළත් කළ යුතු අවසාන අංගයට .
• හිස් අගයන් පහත පරිදි පැහැර හරිනු ලැබේ : [+0:-0:1].
• Step ණාත්මක පියවරක් භාවිතා කිරීම startසහend

අංකනය (අංකිත) න්‍යාස සහ බහුමාන අරා දක්වා විහිදේ. උදාහරණයක් ලෙස, ඔබට භාවිතා කළ හැකි සම්පූර්ණ තීරු කැපීමට:

m[::,0:2:] ## slice the first two columns

පෙති වල අරාව මූලද්‍රව්‍යවල පිටපත් නොව යොමු දැක්වීම් ඇත. ඔබට වෙනම පිටපතක් අරාවක් සෑදීමට අවශ්‍ය නම්, ඔබට භාවිතා කළ හැකිය deepcopy().

ලැයිස්තුවකින් මූලද්‍රව්‍ය එකක් හෝ කිහිපයක් ඉවත් කිරීමට ඔබට පෙති පැවරුම භාවිතා කළ හැකිය:

r = [1, 'blah', 9, 8, 2, 3, 4]
>>> r[1:4] = []
>>> r
[1, 2, 3, 4]

මෙය අමතර තොරතුරු සඳහා පමණි ... පහත ලැයිස්තුව සලකා බලන්න

>>> l=[12,23,345,456,67,7,945,467]

ලැයිස්තුව ආපසු හැරවීමට තවත් උපක්‍රම කිහිපයක්:

>>> l[len(l):-len(l)-1:-1]
[467, 945, 7, 67, 456, 345, 23, 12]

>>> l[:-len(l)-1:-1]
[467, 945, 7, 67, 456, 345, 23, 12]

>>> l[len(l)::-1]
[467, 945, 7, 67, 456, 345, 23, 12]

>>> l[::-1]
[467, 945, 7, 67, 456, 345, 23, 12]

>>> l[-1:-len(l)-1:-1]
[467, 945, 7, 67, 456, 345, 23, 12]

අළුත් අයට මම පෙති උගන්වන ආකාරය මෙයයි:

සුචිගත කිරීම සහ කැපීම අතර වෙනස අවබෝධ කර ගැනීම:

විකී පයිතන් සතුව මෙම විශ්මය ජනක පින්තූරය ඇත.

එය එහි මූලද්‍රව්‍ය හයක් සහිත ලැයිස්තුවකි. පෙති කැපීම වඩා හොඳින් තේරුම් ගැනීමට, එම ලැයිස්තුව පෙට්ටි හයක එකතුවක් ලෙස සලකන්න. සෑම පෙට්ටියකම අක්ෂර මාලාවක් ඇත.

සුචිගත කිරීම කොටුවේ අන්තර්ගතය සමඟ කටයුතු කිරීමක් වැනිය. ඔබට ඕනෑම කොටුවක අන්තර්ගතය පරීක්ෂා කළ හැකිය. නමුත් ඔබට එකවර බහු කොටු වල අන්තර්ගතය පරීක්ෂා කළ නොහැක. ඔබට කොටුවේ අන්තර්ගතය පවා ප්රතිස්ථාපනය කළ හැකිය. නමුත් ඔබට එක් පෙට්ටියක බෝල දෙකක් තැබීමට හෝ එකවර බෝල දෙකක් ආදේශ කිරීමට නොහැකිය.

In [122]: alpha = ['a', 'b', 'c', 'd', 'e', 'f']

In [123]: alpha
Out[123]: ['a', 'b', 'c', 'd', 'e', 'f']

In [124]: alpha[0]
Out[124]: 'a'

In [127]: alpha[0] = 'A'

In [128]: alpha
Out[128]: ['A', 'b', 'c', 'd', 'e', 'f']

In [129]: alpha[0,1]
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-129-c7eb16585371> in <module>()
----> 1 alpha[0,1]

TypeError: list indices must be integers, not tuple

පෙති කැපීම හරියට පෙට්ටි සමඟ ගනුදෙනු කිරීමක් වැනිය. ඔබට පළමු කොටුව රැගෙන වෙනත් මේසයක් මත තැබිය හැකිය. කොටුව ලබා ගැනීම සඳහා, ඔබ දැනගත යුතු වන්නේ කොටුවේ ආරම්භයේ සහ අවසානයේ පිහිටීමයි.

ඔබට පළමු පෙට්ටි තුන හෝ අවසාන පෙට්ටි දෙක හෝ 1 සහ 4 අතර ඇති සියලුම පෙට්ටි පවා ලබා ගත හැකිය. එබැවින්, ආරම්භය සහ අවසානය ඔබ දන්නේ නම් ඔබට ඕනෑම පෙට්ටි කට්ටලයක් තෝරා ගත හැකිය. මෙම තනතුරු ආරම්භක සහ නැවතුම් ස්ථාන ලෙස හැඳින්වේ.

සිත්ගන්නා කරුණ නම් ඔබට එකවර පෙට්ටි කිහිපයක් ප්‍රතිස්ථාපනය කළ හැකිය. එසේම ඔබ කැමති තැනක බහු කොටු තැබිය හැකිය.

In [130]: alpha[0:1]
Out[130]: ['A']

In [131]: alpha[0:1] = 'a'

In [132]: alpha
Out[132]: ['a', 'b', 'c', 'd', 'e', 'f']

In [133]: alpha[0:2] = ['A', 'B']

In [134]: alpha
Out[134]: ['A', 'B', 'c', 'd', 'e', 'f']

In [135]: alpha[2:2] = ['x', 'xx']

In [136]: alpha
Out[136]: ['A', 'B', 'x', 'xx', 'c', 'd', 'e', 'f']

පියවර සමඟ කැපීම:

මේ වන තෙක් ඔබ අඛණ්ඩව පෙට්ටි තෝරාගෙන ඇත. නමුත් සමහර විට ඔබ නුවණින් යුතුව තෝරා ගත යුතුය. උදාහරණයක් ලෙස, ඔබට සෑම දෙවන පෙට්ටියක්ම තෝරා ගත හැකිය. ඔබට සෑම තෙවන පෙට්ටියක්ම අවසානයේ සිට ලබා ගත හැකිය. මෙම අගය පියවර ප්‍රමාණය ලෙස හැඳින්වේ. මෙය ඔබගේ අනුප්‍රාප්තික පිකප් අතර පරතරය නිරූපණය කරයි. ඔබ මුල සිට අග දක්වා පෙට්ටි තෝරා ගන්නේ නම් සහ අනෙක් අතට පියවර විශාලත්වය ධනාත්මක විය යුතුය.

In [137]: alpha = ['a', 'b', 'c', 'd', 'e', 'f']

In [142]: alpha[1:5:2]
Out[142]: ['b', 'd']

In [143]: alpha[-1:-5:-2]
Out[143]: ['f', 'd']

In [144]: alpha[1:5:-2]
Out[144]: []

In [145]: alpha[-1:-5:2]
Out[145]: []

පයිතන් අතුරුදහන් වූ පරාමිතීන් හඳුනා ගන්නේ කෙසේද:

පෙති කපන විට, ඔබ කිසියම් පරාමිතියක් අතහැර දැමුවහොත්, පයිතන් එය ස්වයංක්‍රීයව හඳුනා ගැනීමට උත්සාහ කරයි.

ඔබ CPython හි ප්‍රභව කේතය පරීක්ෂා කරන්නේ නම් , ඔබ) PySlice_GetIndicesEx (නමින් කාර්යය ඕනෑම පරාමිතීන් සඳහා පෙත්තක් දර්ශක අතරින් සංඛ්යා වන ඔබට පෙනී යනු ඇත. මෙන්න පයිතන් හි තාර්කික සමාන කේතය.

මෙම ශ්‍රිතය පෙති කැපීම සඳහා පයිතන් වස්තුවක් සහ විකල්ප පරාමිතීන් ගෙන ඉල්ලූ පෙත්ත සඳහා ආරම්භක, නැවතුම්, පියවර සහ පෙති දිග ලබා දෙයි.

def py_slice_get_indices_ex(obj, start=None, stop=None, step=None):

    length = len(obj)

    if step is None:
        step = 1
    if step == 0:
        raise Exception("Step cannot be zero.")

    if start is None:
        start = 0 if step > 0 else length - 1
    else:
        if start < 0:
            start += length
        if start < 0:
            start = 0 if step > 0 else -1
        if start >= length:
            start = length if step > 0 else length - 1

    if stop is None:
        stop = length if step > 0 else -1
    else:
        if stop < 0:
            stop += length
        if stop < 0:
            stop = 0 if step > 0 else -1
        if stop >= length:
            stop = length if step > 0 else length - 1

    if (step < 0 and stop >= start) or (step > 0 and start >= stop):
        slice_length = 0
    elif step < 0:
        slice_length = (stop - start + 1)/(step) + 1
    else:
        slice_length = (stop - start - 1)/(step) + 1

    return (start, stop, step, slice_length)

පෙති පිටුපස ඇති බුද්ධිය මෙයයි. පයිතන්ට ස්ලයිස් නමින් සාදන ලද ශ්‍රිතයක් ඇති බැවින්, ඔබට පරාමිති කිහිපයක් පසු කර අතුරුදහන් වූ පරාමිතීන් ගණනය කරන්නේ කෙසේදැයි විමසා බැලිය හැකිය.

In [21]: alpha = ['a', 'b', 'c', 'd', 'e', 'f']

In [22]: s = slice(None, None, None)

In [23]: s
Out[23]: slice(None, None, None)

In [24]: s.indices(len(alpha))
Out[24]: (0, 6, 1)

In [25]: range(*s.indices(len(alpha)))
Out[25]: [0, 1, 2, 3, 4, 5]

In [26]: s = slice(None, None, -1)

In [27]: range(*s.indices(len(alpha)))
Out[27]: [5, 4, 3, 2, 1, 0]

In [28]: s = slice(None, 3, -1)

In [29]: range(*s.indices(len(alpha)))
Out[29]: [5, 4]

සටහන: මෙම ලිපිය මුලින් ලියා ඇත්තේ පයිතන් පෙති පිටුපස ඇති බුද්ධියයි .

සාමාන්‍ය රීතියක් ලෙස, දෘඩ කේත කරන ලද දර්ශක අගයන් සහිත කේත ලිවීම කියවීමේ හැකියාව සහ නඩත්තු කිරීමේ අවුලකට මඟ පාදයි. උදාහරණයක් ලෙස, ඔබ වසරකට පසුව නැවත කේතය වෙත පැමිණියහොත්, ඔබ එය දෙස බලා එය ලියන විට ඔබ සිතන්නේ කුමක්දැයි කල්පනා කරයි. පෙන්වා ඇති විසඳුම ඔබේ කේතය ඇත්ත වශයෙන්ම කරන්නේ කුමක්ද යන්න වඩාත් පැහැදිලිව ප්‍රකාශ කිරීමේ ක්‍රමයකි. පොදුවේ ගත් කල, සාදන ලද පෙත්තක් () පෙත්තක් ඉඩ දී ඇති ඕනෑම තැනක භාවිතා කළ හැකි පෙති වස්තුවක් නිර්මාණය කරයි. උදාහරණයක් වශයෙන්:

>>> items = [0, 1, 2, 3, 4, 5, 6]
>>> a = slice(2, 4)
>>> items[2:4]
[2, 3]
>>> items[a]
[2, 3]
>>> items[a] = [10,11]
>>> items
[0, 1, 10, 11, 4, 5, 6]
>>> del items[a]
>>> items
[0, 1, 4, 5, 6]

ඔබට පෙති නිදසුනක් තිබේ නම්, පිළිවෙලින් එහි s.start, s.stop, සහ s.step ගුණාංග දෙස බැලීමෙන් ඔබට ඒ පිළිබඳ වැඩි විස්තර ලබා ගත හැකිය. උදාහරණයක් වශයෙන්:

>>> a = slice(10, 50, 2)
>>> a.start
10
>>> a.stop
50
>>> a.step
2
>>>

1. පෙති අංකනය

එය සරල කිරීම සඳහා, පෙත්තක් ඇත්තේ එක් ආකාරයක් පමණක් බව මතක තබා ගන්න

s[start:end:step]

එය ක්‍රියාත්මක වන ආකාරය මෙන්න:

• s: කැපිය හැකි වස්තුවක්
• start: නැවත ආරම්භ කිරීම ආරම්භ කළ පළමු දර්ශකය
• end: අවසාන දර්ශකය, ප්‍රති index ල පෙත්තට endදර්ශකය ඇතුළත් නොවන බව සලකන්න
• step: සෑම stepදර්ශකයක්ම මූලද්‍රව්‍යය තෝරන්න

තවත් ආනයන දෙයක්: සියලු start, end, stepනොකරන හරින ලද හැකි! ඔවුන් නොකරන හරින ලද නම්, පෙරනිමි අගය භාවිතා කරනු ලැබේ: 0, len(s), 1ඒ අනුව.

එබැවින් විය හැකි වෙනස්කම්:

# Mostly used variations
s[start:end]
s[start:]
s[:end]

# Step-related variations
s[:end:step]
s[start::step]
s[::step]

# Make a copy
s[:]

සටහන: start >= end(කවදාද යන්න සලකා බැලුවහොත් step>0), පයිතන් හිස් පෙත්තක් ලබා දෙනු []ඇත.

2. අන්තරායන්

පෙත්තක් ක්‍රියා කරන ආකාරය පිළිබඳ මූලික ලක්ෂණ ඉහත කොටසින් පැහැදිලි කෙරෙන අතර එය බොහෝ අවස්ථාවන්හිදී ක්‍රියා කරනු ඇත. කෙසේ වෙතත්, ඔබ අවධානයෙන් සිටිය යුතු අන්තරායන් තිබිය හැකි අතර, මෙම කොටස ඒවා පැහැදිලි කරයි.

සෘණ දර්ශක

පයිතන් ඉගෙන ගන්නන් ව්‍යාකූල කරන පළමු දෙය නම් දර්ශකයක් negative ණ විය හැකි බවයි! කලබල නොවන්න: negative ණ දර්ශකයක් යනු පසුපසට ගණන් කිරීමයි.

උදාහරණයක් වශයෙන්:

s[-5:]    # Start at the 5th index from the end of array,
          # thus returning the last 5 elements.
s[:-5]    # Start at index 0, and end until the 5th index from end of array,
          # thus returning s[0:len(s)-5].

සෘණ පියවර

දේවල් වඩාත් අවුල් සහගත කිරීම stepnegative ණාත්මක විය හැකිය!

Step ණාත්මක පියවරක් යනු අරාව පසුපසට නැවත යොමු කිරීමයි: අවසානයේ සිට ආරම්භය දක්වා, අවසාන දර්ශකය ඇතුළත් කර ඇති අතර ආරම්භක දර්ශකය ප්‍රති .ලයෙන් බැහැර කර ඇත.

සටහන : පියවර negative ණ වන විට, සඳහා පෙරනිමි අගය startවේ len(s)(අතර endසමාන නොවන අතර 0, s[::-1]අඩංගු බැවින් s[0]). උදාහරණයක් වශයෙන්:

s[::-1]            # Reversed slice
s[len(s)::-1]      # The same as above, reversed slice
s[0:len(s):-1]     # Empty list

පරාසයේ දෝෂයක් තිබේද?

පුදුම වන්න: දර්ශකය පරාසය ඉක්මවා ගිය විට පෙත්තක් දර්ශක දෝෂයක් මතු නොකරයි!

දර්ශකය පරාසය ඉක්මවා ඇත්නම්, පයිතන් දර්ශකය තත්වයට අනුව 0හෝ len(s)අනුව සකස් කිරීමට උපරිම උත්සාහයක් දරයි . උදාහරණයක් වශයෙන්:

s[:len(s)+5]      # The same as s[:len(s)]
s[-len(s)-5::]    # The same as s[0:]
s[len(s)+5::-1]   # The same as s[len(s)::-1], and the same as s[::-1]

3. උදාහරණ

අපි සාකච්ඡා කළ සියල්ල පැහැදිලි කරමින් උදාහරණ සමඟ මෙම පිළිතුර අවසන් කරමු:

# Create our array for demonstration
In [1]: s = [i for i in range(10)]

In [2]: s
Out[2]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [3]: s[2:]   # From index 2 to last index
Out[3]: [2, 3, 4, 5, 6, 7, 8, 9]

In [4]: s[:8]   # From index 0 up to index 8
Out[4]: [0, 1, 2, 3, 4, 5, 6, 7]

In [5]: s[4:7]  # From index 4 (included) up to index 7(excluded)
Out[5]: [4, 5, 6]

In [6]: s[:-2]  # Up to second last index (negative index)
Out[6]: [0, 1, 2, 3, 4, 5, 6, 7]

In [7]: s[-2:]  # From second last index (negative index)
Out[7]: [8, 9]

In [8]: s[::-1] # From last to first in reverse order (negative step)
Out[8]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

In [9]: s[::-2] # All odd numbers in reversed order
Out[9]: [9, 7, 5, 3, 1]

In [11]: s[-2::-2] # All even numbers in reversed order
Out[11]: [8, 6, 4, 2, 0]

In [12]: s[3:15]   # End is out of range, and Python will set it to len(s).
Out[12]: [3, 4, 5, 6, 7, 8, 9]

In [14]: s[5:1]    # Start > end; return empty list
Out[14]: []

In [15]: s[11]     # Access index 11 (greater than len(s)) will raise an IndexError
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-15-79ffc22473a3> in <module>()
----> 1 s[11]

IndexError: list index out of range

පෙර පිළිතුරු සුප්‍රසිද්ධ NumPy පැකේජය භාවිතයෙන් කළ හැකි බහු-මාන අරාව කැපීම ගැන සාකච්ඡා නොකරයි :

පෙති කැපීම බහු-මාන අරා සඳහා ද යෙදිය හැකිය.

# Here, a is a NumPy array

>>> a
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])
>>> a[:2, 0:3:2]
array([[1, 3],
       [5, 7]])

ඇති " :2" කොමාව පෙර පළමු මානයක් සිය මෙහෙයුම් කටයුතු සිදු කරන අතර " 0:3:2" කොමාව දෙවන මානයක් ක්රියාත්මක පසු.

#!/usr/bin/env python

def slicegraphical(s, lista):

    if len(s) > 9:
        print """Enter a string of maximum 9 characters,
    so the printig would looki nice"""
        return 0;
    # print " ",
    print '  '+'+---' * len(s) +'+'
    print ' ',
    for letter in s:
        print '| {}'.format(letter),
    print '|'
    print " ",; print '+---' * len(s) +'+'

    print " ",
    for letter in range(len(s) +1):
        print '{}  '.format(letter),
    print ""
    for letter in range(-1*(len(s)), 0):
        print ' {}'.format(letter),
    print ''
    print ''


    for triada in lista:
        if len(triada) == 3:
            if triada[0]==None and triada[1] == None and triada[2] == None:
                # 000
                print s+'[   :   :   ]' +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] == None and triada[1] == None and triada[2] != None:
                # 001
                print s+'[   :   :{0:2d} ]'.format(triada[2], '','') +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] == None and triada[1] != None and triada[2] == None:
                # 010
                print s+'[   :{0:2d} :   ]'.format(triada[1]) +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] == None and triada[1] != None and triada[2] != None:
                # 011
                print s+'[   :{0:2d} :{1:2d} ]'.format(triada[1], triada[2]) +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] != None and triada[1] == None and triada[2] == None:
                # 100
                print s+'[{0:2d} :   :   ]'.format(triada[0]) +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] != None and triada[1] == None and triada[2] != None:
                # 101
                print s+'[{0:2d} :   :{1:2d} ]'.format(triada[0], triada[2]) +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] != None and triada[1] != None and triada[2] == None:
                # 110
                print s+'[{0:2d} :{1:2d} :   ]'.format(triada[0], triada[1]) +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] != None and triada[1] != None and triada[2] != None:
                # 111
                print s+'[{0:2d} :{1:2d} :{2:2d} ]'.format(triada[0], triada[1], triada[2]) +' = ', s[triada[0]:triada[1]:triada[2]]

        elif len(triada) == 2:
            if triada[0] == None and triada[1] == None:
                # 00
                print s+'[   :   ]    ' + ' = ', s[triada[0]:triada[1]]
            elif triada[0] == None and triada[1] != None:
                # 01
                print s+'[   :{0:2d} ]    '.format(triada[1]) + ' = ', s[triada[0]:triada[1]]
            elif triada[0] != None and triada[1] == None:
                # 10
                print s+'[{0:2d} :   ]    '.format(triada[0]) + ' = ', s[triada[0]:triada[1]]
            elif triada[0] != None and triada[1] != None:
                # 11
                print s+'[{0:2d} :{1:2d} ]    '.format(triada[0],triada[1]) + ' = ', s[triada[0]:triada[1]]

        elif len(triada) == 1:
            print s+'[{0:2d} ]        '.format(triada[0]) + ' = ', s[triada[0]]


if __name__ == '__main__':
    # Change "s" to what ever string you like, make it 9 characters for
    # better representation.
    s = 'COMPUTERS'

    # add to this list different lists to experement with indexes
    # to represent ex. s[::], use s[None, None,None], otherwise you get an error
    # for s[2:] use s[2:None]

    lista = [[4,7],[2,5,2],[-5,1,-1],[4],[-4,-6,-1], [2,-3,1],[2,-3,-1], [None,None,-1],[-5,None],[-5,0,-1],[-5,None,-1],[-1,1,-2]]

    slicegraphical(s, lista)

ඔබට මෙම ස්ක්‍රිප්ට් එක ධාවනය කර එය අත්හදා බැලිය හැකිය, පහත දැක්වෙන්නේ මට පිටපතෙන් ලබාගත් සාම්පල කිහිපයක්.

  +---+---+---+---+---+---+---+---+---+
  | C | O | M | P | U | T | E | R | S |
  +---+---+---+---+---+---+---+---+---+
  0   1   2   3   4   5   6   7   8   9   
 -9  -8  -7  -6  -5  -4  -3  -2  -1 

COMPUTERS[ 4 : 7 ]     =  UTE
COMPUTERS[ 2 : 5 : 2 ] =  MU
COMPUTERS[-5 : 1 :-1 ] =  UPM
COMPUTERS[ 4 ]         =  U
COMPUTERS[-4 :-6 :-1 ] =  TU
COMPUTERS[ 2 :-3 : 1 ] =  MPUT
COMPUTERS[ 2 :-3 :-1 ] =  
COMPUTERS[   :   :-1 ] =  SRETUPMOC
COMPUTERS[-5 :   ]     =  UTERS
COMPUTERS[-5 : 0 :-1 ] =  UPMO
COMPUTERS[-5 :   :-1 ] =  UPMOC
COMPUTERS[-1 : 1 :-2 ] =  SEUM
[Finished in 0.9s]

Negative ණාත්මක පියවරක් භාවිතා කරන විට, පිළිතුර 1 කින් දකුණට මාරු කර ඇති බව සැලකිල්ලට ගන්න.

-එය අයිතමය lst[start:end]අඩංගු බව පිළිගැනීමට මගේ මොළය සතුටු වන බව පෙනේ start. එය 'ස්වාභාවික උපකල්පනයක්' යැයි මට පැවසිය හැකිය.

නමුත් ඉඳහිට සැකයක් ඇති වන අතර මගේ මොළය එහි end-එය මූලද්‍රව්‍යය අඩංගු නොවන බවට සහතිකයක් ඉල්ලා සිටී .

මේ මොහොතේ මම මෙම සරල ප්‍රමේයය මත රඳා සිටිමි:

for any n,    lst = lst[:n] + lst[n:]

මෙම ලස්සන දේපල මට පවසන්නේ එය ඇති බැවින්-වන අයිතමය lst[start:end]අඩංගු නොවන බවයි .endlst[end:]

මෙම ප්‍රමේයය ඕනෑම කෙනෙකුට සත්‍ය බව සලකන්න n. උදාහරණයක් ලෙස, ඔබට එය පරීක්ෂා කළ හැකිය

lst = range(10)
lst[:-42] + lst[-42:] == lst

ප්‍රතිලාභ True.

මගේ මතය අනුව, ඔබ පහත දැක්වෙන ආකාරයෙන් බැලුවහොත් පයිතන් නූල් පෙති කැපීමේ අංකනය වඩා හොඳින් තේරුම් ගෙන කටපාඩම් කරනු ඇත (කියවන්න).

පහත දැක්වෙන නූල සමඟ වැඩ කරමු ...

azString = "abcdefghijklmnopqrstuvwxyz"

නොදන්නා අය සඳහා, ඔබට azStringඅංකනය භාවිතා කිරීමෙන් ඕනෑම උපස්ථරයක් සෑදිය හැකියazString[x:y]

වෙනත් ක්‍රමලේඛන භාෂාවලින් එන විට සාමාන්‍ය බුද්ධිය අඩපණ වේ. X සහ y යනු කුමක්ද?

X සහ y යනු කුමක්දැයි මතක තබා ගැනීමට සහ පළමු උත්සාහයේදී නූල් නිසි ලෙස කැපීමට මට උපකාරී වන කටපාඩම් කිරීමේ තාක්ෂණයක් සඳහා වූ මගේ ගවේෂණයේ දී මට වාඩි වී අවස්ථා කිහිපයක් ක්‍රියාත්මක කිරීමට සිදු විය.

මගේ නිගමනය වන්නේ x සහ y අපට අමතර කිරීමට අවශ්‍ය නූල් වටා ඇති මායිම් දර්ශක ලෙස දැකිය යුතු බවයි. එබැවින් අප ප්‍රකාශනය දැකිය යුත්තේ azString[index1, index2]ඊටත් වඩා පැහැදිලිවය azString[index_of_first_character, index_after_the_last_character].

මෙන්න එය දෘශ්‍යකරණය කිරීමේ උදාහරණයකි ...

Letters   a b c d e f g h i j ...
         ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑
             ┊           ┊
Indexes  0 1 2 3 4 5 6 7 8 9 ...
             ┊           ┊
cdefgh    index1       index2

එබැවින් ඔබ කළ යුතුව ඇත්තේ අපේක්ෂිත උපස්ථරය වටා ඇති අගයන්ට දර්ශක 1 සහ දර්ශක 2 සැකසීම පමණි. උදාහරණයක් ලෙස, "cdefgh" උපස්ථරය ලබා ගැනීම සඳහා, ඔබට භාවිතා කළ හැකියazString[2:8] , මන්ද "c" හි වම් පැත්තේ දර්ශකය 2 ක් වන අතර "h" හි නිවැරදි ප්‍රමාණය 8 වේ.

අපි සීමාවන් සකස් කරන බව මතක තබා ගන්න. එම සීමාවන් යනු ඔබට මේ වගේ උපස්ථරය වටා ඔතා ඇති වරහන් කිහිපයක් තැබිය හැකි ස්ථාන වේ ...

ab [ cdefgh ] ij

එම උපක්‍රමය සැමවිටම ක්‍රියාත්මක වන අතර කටපාඩම් කිරීම පහසුය.

පෙර පිළිතුරු බොහොමයක් පෙති අංකනය පිළිබඳ ප්‍රශ්න ඉවත් කරයි.

පෙති කැපීම සඳහා භාවිතා කරන දීර් index සුචිගත කිරීමේ වාක්‍ය ඛණ්ඩය වන aList[start:stop:step]අතර මූලික උදාහරණ නම්:

:

තවත් පෙති කපන උදාහරණ: පුළුල් කළ පෙති 15 ක්

පයිතන්හි, පෙති කැපීම සඳහා මූලිකම ක්‍රමය පහත දැක්වේ:

l[start:end]

කොහේද lයම් එකතුවක්, startසියල්ල ඇතුළත් දර්ශකයක් වන අතර endඑය සුවිශේෂී දර්ශකයකි.

In [1]: l = list(range(10))

In [2]: l[:5] # First five elements
Out[2]: [0, 1, 2, 3, 4]

In [3]: l[-5:] # Last five elements
Out[3]: [5, 6, 7, 8, 9]

ආරම්භයේ සිට පෙති කපන විට, ඔබට ශුන්‍ය දර්ශකය මඟ හැරිය හැකි අතර, අවසානය දක්වා පෙති කපන විට, අවසාන දර්ශකය අතිරික්ත බැවින් ඔබට එය මඟ හැරිය හැක, එබැවින් වාචික නොවන්න:

In [5]: l[:3] == l[0:3]
Out[5]: True

In [6]: l[7:] == l[7:len(l)]
Out[6]: True

එකතුවක අවසානයට සාපේක්ෂව ඕෆ්සෙට් සිදු කිරීමේදී සෘණ පූර්ණ සංඛ්‍යා ප්‍රයෝජනවත් වේ:

In [7]: l[:-1] # Include all elements but the last one
Out[7]: [0, 1, 2, 3, 4, 5, 6, 7, 8]

In [8]: l[-3:] # Take the last three elements
Out[8]: [7, 8, 9]

පෙති කපන විට සීමාවෙන් බැහැර වූ දර්ශක සැපයිය හැකිය:

In [9]: l[:20] # 20 is out of index bounds, and l[20] will raise an IndexError exception
Out[9]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [11]: l[-20:] # -20 is out of index bounds, and l[-20] will raise an IndexError exception
Out[11]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

එකතුවක් කැපීමේ ප්‍රති result ලය නව එකතුවක් බව මතක තබා ගන්න. ඊට අමතරව, පැවරුම්වල පෙති අංකනය භාවිතා කරන විට, පෙති පැවරුම්වල දිග සමාන විය යුතු නොවේ. පවරා ඇති පෙත්තකට පෙර සහ පසු අගයන් තබා ඇති අතර නව අගයන් අඩංගු වන පරිදි එකතුව හැකිලෙනු ඇත.

In [16]: l[2:6] = list('abc') # Assigning fewer elements than the ones contained in the sliced collection l[2:6]

In [17]: l
Out[17]: [0, 1, 'a', 'b', 'c', 6, 7, 8, 9]

In [18]: l[2:5] = list('hello') # Assigning more elements than the ones contained in the sliced collection l [2:5]

In [19]: l
Out[19]: [0, 1, 'h', 'e', 'l', 'l', 'o', 6, 7, 8, 9]

ඔබ ආරම්භක සහ අවසාන දර්ශකය මඟ හැරියහොත්, ඔබ එකතුවෙහි පිටපතක් සාදනු ඇත:

In [14]: l_copy = l[:]

In [15]: l == l_copy and l is not l_copy
Out[15]: True

පැවරුම් මෙහෙයුමක් සිදු කිරීමේදී ආරම්භක සහ අවසාන දර්ශක මඟ හැරී ඇත්නම්, එකතුවෙහි සම්පූර්ණ අන්තර්ගතය යොමු කර ඇති දේවල පිටපතක් සමඟ ප්‍රතිස්ථාපනය වේ:

In [20]: l[:] = list('hello...')

In [21]: l
Out[21]: ['h', 'e', 'l', 'l', 'o', '.', '.', '.']

මූලික පෙති කැපීමට අමතරව, පහත දැක්වෙන අංකනය යෙදිය හැකිය:

l[start:end:step]

කොහේද lඑකතුවක්, startඇතුළත් දර්ශකයක්, endසුවිශේෂී දර්ශකයක් වන අතර stepසෑම නවවන අයිතමයක්ම රැගෙන යාමට භාවිතා කළ හැකි පියවරකිl .

In [22]: l = list(range(10))

In [23]: l[::2] # Take the elements which indexes are even
Out[23]: [0, 2, 4, 6, 8]

In [24]: l[1::2] # Take the elements which indexes are odd
Out[24]: [1, 3, 5, 7, 9]