স্লাইস নোটেশন বোঝা
উত্তর:
এটি সত্যিই বেশ সহজ:
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মান প্রথম মান যে প্রতিনিধিত্ব করে না নির্বাচিত ফালি হবে। সুতরাং, এর মধ্যে পার্থক্য stopএবং startনির্বাচিত উপাদানের সংখ্যা হল (যদি step1, ডিফল্ট)।
অন্য বৈশিষ্ট্যটি হ'ল startবা stopa ণাত্মক সংখ্যা হতে পারে যার অর্থ এটি শুরুর পরিবর্তে অ্যারের প্রান্ত থেকে গণনা করা হয়। তাই:
a[-1] # last item in the array
a[-2:] # last two items in the array
a[:-2] # everything except the last two items
একইভাবে, stepএকটি নেতিবাচক সংখ্যা হতে পারে:
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()বস্তুর স্পষ্ট ব্যবহারের ফলে কাটানোর প্রোগ্রামিক প্রজন্মকে সহজতর করা হয়।
Noneখালি জায়গাগুলির কোনওটির জন্য বিকল্প তৈরি করতে পারেন । উদাহরণস্বরূপ [None:None]একটি সম্পূর্ণ অনুলিপি তৈরি করে। এটি কার্যকর হয় যখন আপনাকে ভেরিয়েবল ব্যবহার করে ব্যাপ্তির শেষ নির্দিষ্ট করতে হয় এবং শেষ আইটেমটি অন্তর্ভুক্ত করতে হয়।
delতাই আর্ট স্লাইস নোটেশনটি কী করে তার সাথে একটি বিভাগ যুক্ত করা কি বোধগম্য হবে ? বিশেষত, del arr[:]তাত্ক্ষণিকভাবে স্পষ্ট নয় ("আরআর [:] একটি অনুলিপি তৈরি করে, তাই সেই অনুলিপিটি মুছে
পাইথন টিউটোরিয়াল এটা সম্পর্কে আলোচনা (ক একটু নিচে স্ক্রল পর্যন্ত আপনি slicing সম্পর্কে অংশে পাবেন)।
টুকরো কীভাবে কাজ করে তা মনে রাখার জন্য ASCII আর্ট ডায়াগ্রামটি সহায়ক:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
ওয়ান ওয়ে টুকরা কাজ ইশারা যেমন সূচকের মনে হয় কিভাবে মনে রাখা মধ্যে প্রথম অক্ষর বাম প্রান্ত দিয়ে অক্ষর, সংখ্যা 0. তারপর একটি স্ট্রিং শেষ চরিত্রের ডান প্রান্ত এন অক্ষর সূচক আছে এন ।
a[-4,-6,-1]করা yPকিন্তু এটা ty। অক্ষর বা স্লটগুলিতে চিন্তা করা এবং অর্ধ-খোলা ব্যবধান হিসাবে সূচি ব্যবহার করা - সর্বদা কাজটি হ'ল ধনাত্মক অগ্রগতি হলে ডান-ওপেন, নেতিবাচক স্ট্রাইড হলে বাম-খোলা।
x[:0]), তাই আপনাকে বিশেষ-ছোট ছোট অ্যারে করতে হবে। : /
ব্যাকরণ দ্বারা অনুমোদিত সম্ভাবনাগুলি গণনা করা:
>>> 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।
যদি strideনেতিবাচক হয় তবে অর্ডারটি কিছুটা পরিবর্তন করা হয়েছে যেহেতু আমরা গণনা করছি:
>>> 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]]
প্রসারিত স্লাইসিং (কমা এবং উপবৃত্ত সহ) বেশিরভাগটি কেবল বিশেষ ডেটা স্ট্রাকচার (নুমপির মতো) দ্বারা ব্যবহৃত হয়; প্রাথমিক ক্রমগুলি তাদের সমর্থন করে না।
>>> class slicee:
... def __getitem__(self, item):
... return repr(item)
...
>>> slicee()[0, 1:2, ::5, ...]
'(0, slice(1, 2, None), slice(None, None, 5), Ellipsis)'
repr
__getitem__হ'ল; আপনার উদাহরণ সমান apple[slice(4, -4, -1)]।
উপরের উত্তরগুলি স্লাইস অ্যাসাইনমেন্ট নিয়ে আলোচনা করে না। স্লাইস অ্যাসাইনমেন্ট বুঝতে, এটি 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']
একটি হিউরিস্টিক হ'ল শূন্য থেকে এন টুকরার জন্য, ভাবেন: "শূন্যটি শুরু, শুরুতে শুরু করুন এবং এন আইটেমগুলিকে একটি তালিকায় নিয়ে যান"।
>>> 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) পরিবর্তন করছি না, তাই খালি স্লাইসটি নির্ধারিত করেও sertedোকানো আইটেমগুলি সর্বদা 'ও' এর বিপরীতে স্ট্যাক আপ করে দেয়। সুতরাং খালি স্লাইস অ্যাসাইনমেন্টের জন্য অবস্থানটি খালি খালি স্লাইস অ্যাসাইনমেন্টের জন্য পজিশনের যৌক্তিক বর্ধন।
কিছুটা ব্যাক আপ করা, আপনি যখন আমাদের স্লাইস শুরুর গণনা শোভাযাত্রা চালিয়ে যাবেন তখন কি হবে?
>>> 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]
[]
কাটা দিয়ে, একবার হয়ে গেলে আপনি শেষ হয়ে গেলেন; এটি পিছনের দিকে কাটা শুরু করে না। পাইথনে আপনি নেতিবাচক পদক্ষেপ পাবেন না যদি না আপনি স্পষ্টভাবে একটি নেতিবাচক সংখ্যা ব্যবহার করে তাদের জন্য জিজ্ঞাসা করেন।
>>> 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 থেকে ডিফল্ট হয়, অর্থাৎ প্রথম সূচক। যদি এটি নেতিবাচক হয় তবে এর অর্থ
nআইটেমগুলি শেষ থেকে শুরু করা ।স্টপ: স্লাইজের সমাপ্তি সূচক, এটি এই সূচকে উপাদানটি অন্তর্ভুক্ত করে না , ক্রমটি কাটা হওয়ার ক্রমের দৈর্ঘ্যের ডিফল্ট, অর্থাৎ শেষ পর্যন্ত এবং অন্তর্ভুক্ত।
পদক্ষেপ: সূচকটি যে পরিমাণে বৃদ্ধি পায়, ডিফল্ট হয় ১ এ এটি যদি নেতিবাচক হয় তবে আপনি বিপরীতে পুনরাবৃত্তের উপরে টুকরো টুকরো করে চলেছেন।
সূচক কীভাবে কাজ করে
আপনি এই যেকোন ধনাত্মক বা নেতিবাচক সংখ্যা তৈরি করতে পারেন। ইতিবাচক সংখ্যার অর্থ সহজবোধ্য কিন্তু ঋণাত্মক সংখ্যা জন্য, শুধু পাইথন মধ্যে ইনডেক্স মতো, আপনি পিছন জন্য আবার শেষ থেকে গণনা শুরু এবং স্টপ , এবং পদক্ষেপ , আপনি কেবল আপনার সূচক হ্রাস। এই উদাহরণটি ডকুমেন্টেশনের টিউটোরিয়াল থেকে এসেছে , তবে প্রতিটি সূচীটি রেফারেন্স অনুসারে কোন আইটেমকে ক্রমানুসারে নির্দেশ করতে আমি এটিকে সামান্য সংশোধন করেছি:
+---+---+---+---+---+---+
| 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]এবং ডিফল্টগুলি প্রতিস্থাপন করতে (আসলে যখন stepনেতিবাচক হয় তখন stopএর ডিফল্ট হয় -len(my_list) - 1, তাই Noneথামার জন্য সত্যিকার অর্থে এটি শেষ পদক্ষেপে যে কোনও পদক্ষেপে চলে যায়):
my_list[-9:len(my_list):1]কোলন , :, কি পাইথন বলে আপনি এটা একটি ফালি এবং একটি নিয়মিত সূচক প্রদান করছি হয়। এজন্য পাইথন 2 এ তালিকার একটি অগভীর অনুলিপি তৈরির বুদ্ধিমান পদ্ধতি
list_copy = sequence[:]এবং তাদের সাফ করার সাথে রয়েছে:
del my_list[:](পাইথন 3 একটি list.copyএবং list.clearপদ্ধতি পায় ))
যখন stepনেতিবাচক হয়, তখন ডিফল্ট startএবং stopপরিবর্তিত হয়
ডিফল্টরূপে, যখন stepআর্গুমেন্ট খালি থাকে (বা None), এটি বরাদ্দ করা হয় +1।
তবে আপনি একটি নেতিবাচক পূর্ণসংখ্যায় পাস করতে পারেন, এবং তালিকাটি (বা বেশিরভাগ অন্যান্য স্ট্যান্ডার্ড স্লাইজেবল) শেষ থেকে শুরু পর্যন্ত কাটা হবে।
এভাবে একটি নেতিবাচক ফালি ডিফল্ট-পরিবর্তন হবে startএবং stop!
উত্স এ নিশ্চিত করা
আমি ব্যবহারকারীদের উত্স পাশাপাশি ডকুমেন্টেশন পড়তে উত্সাহিত করতে চাই। ফালি জন্য সোর্স কোড বস্তু এবং এই যুক্তি এখানে পাওয়া যায় । প্রথমে আমরা নির্ধারণ করি stepনেতিবাচক কিনা :
step_is_negative = step_sign < 0;
যদি তা হয় তবে নীচের গণ্ডির -1 অর্থ আমরা শুরু পর্যন্ত সমস্ত উপায় স্লাইস করি এবং উপরের সীমাটি দৈর্ঘ্য বিয়োগ 1, যার অর্থ আমরা শেষে শুরু করি। (নোট যে এই শব্দার্থবিদ্যা -1হয় বিভিন্ন A থেকে -1ব্যবহারকারীরা শেষ আইটেম ইঙ্গিত পাইথন মধ্যে ইনডেক্স পাস হতে পারে।)
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]পাইথনে ২.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] বলছেন, আপনি সি (আগাম বা পিছন) এর চিহ্নের উপর নির্ভর করে বলছেন, a থেকে শুরু করুন এবং b এ শেষ হবে (বিটি সূচকে উপাদান বাদে)। উপরের সূচী নিয়মটি ব্যবহার করুন এবং মনে রাখবেন আপনি কেবল এই সীমাতে উপাদানগুলি পাবেন:
-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 সমান হয় তবে আপনি খালি তালিকা পান:
>>> 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]a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]; a[:-2:-2]যার ফলাফল[9]
এই দুর্দান্ত টেবিলটি 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)এগুলির যে কোনও alচ্ছিক:
(:to:step)
(from::step)
(from:to)তারপরে নেতিবাচক সূচকের জন্য এটি বোঝার জন্য আপনাকে স্ট্রিংয়ের দৈর্ঘ্য নেতিবাচক সূচকে যুক্ত করতে হবে।
এটি যাইহোক আমার জন্য কাজ করে ...
এটি কীভাবে কাজ করে তা মনে রাখা আমার পক্ষে সহজ মনে হয় এবং তারপরে আমি কোনও নির্দিষ্ট শুরু / স্টপ / পদক্ষেপের সমন্বয় বের করতে পারি।
এটি 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। খুব সহজ.
নেতিবাচক পদক্ষেপের কথা মনে রাখার বিষয়টি stopএটি সর্বদা বাদ যায় it's যদি আপনি বিপরীতে ক্রমে একই স্লাইস চান, তবে বিপরীতমুখীভাবে পৃথক করে নেওয়া আরও পরিষ্কার: উদাহরণস্বরূপ 'abcde'[1:-2][::-1]বাম দিক থেকে একটি চরে টুকরো টুকরো, ডান দিক থেকে দুটি, তারপরে বিপরীত হয়। (আরও দেখুন reversed()।)
সিক্যুয়েন্স স্লাইসিং সমান, এটি প্রথমে নেতিবাচক সূচকে স্বাভাবিক করে তোলে এবং এটি ক্রমের বাইরে কখনও যেতে পারে না:
টোডো : অ্যাবস (পদক্ষেপ)> 1 এ যখন নীচের কোডটিতে "কখনই অনুক্রমের বাইরে যাবেন না" দিয়ে একটি বাগ ছিল; আমি মনে করি আমি এটি সঠিকভাবে প্যাচ করেছি তবে এটি বোঝা শক্ত।
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সর্বদা আপনাকে পুরো ক্রমটি দেওয়ার জন্য সঠিক কাজ করে।
নেতিবাচক সূচকে সাধারণকরণ প্রথমে প্রারম্ভ থেকে এবং / বা স্টপকে স্বাধীনভাবে গণনা করা যায়: 'abcde'[1:-2] == 'abcde'[1:3] == 'bc'সত্ত্বেও range(1,-2) == []। স্বাভাবিককরণকে কখনও কখনও "দৈর্ঘ্যের দৈর্ঘ্য" হিসাবে ভাবা হয় তবে নোট করুন এটি দৈর্ঘ্যটি একবারে যুক্ত করেছে: উদাহরণস্বরূপ 'abcde'[-53:42]পুরো স্ট্রিংটি।
this_is_how_slicing_worksপাইথন ফালি হিসাবে একই নয়। ইজি [0, 1, 2][-5:3:3]পাইথনে [0] পাবে তবে list(this_is_how_slicing_works([0, 1, 2], -5, 3, 3))পাবে [1]।
range(4)[-200:200:3] == [0, 3]কিন্তু list(this_is_how_slicing_works([0, 1, 2, 3], -200, 200, 3)) == [2]। আমার if 0 <= i < len(seq):চেষ্টাটি "ক্রমটির বাইরে কখনও যাবেন না" বাস্তবায়নের চেষ্টা ছিল তবে পদক্ষেপ> 1 এর জন্য এটি ভুল। আমি আজ এটি পরে আবার লিখব (পরীক্ষা সহ)।
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]। - একটি নেতিবাচক পদক্ষেপ ব্যবহার ব্যাখ্যার reverses
startএবংend
স্বরলিপিটি (নমপি) ম্যাট্রিকেস এবং বহুমাত্রিক অ্যারে পর্যন্ত প্রসারিত। উদাহরণস্বরূপ, পুরো কলামগুলি স্লাইস করতে আপনি এটি ব্যবহার করতে পারেন:
m[::,0:2:] ## slice the first two columnsস্লাইসগুলি অ্যারের উপাদানগুলির অনুলিপিগুলি নয়, রেফারেন্স ধারণ করে। আপনি যদি আলাদা কপিটি অ্যারে করতে চান তবে আপনি ব্যবহার করতে পারেন deepcopy()।
এটি কেবলমাত্র কিছু অতিরিক্ত তথ্যের জন্য ... নীচের তালিকাটি বিবেচনা করুন
>>> 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 এর মধ্যে সমস্ত বাক্স বাছাই করতে পারেন So সুতরাং, আপনি কোনও সেট বাক্স চয়ন করতে পারেন যদি আপনি শুরু এবং শেষ জানেন। এই অবস্থানগুলিকে স্টার্ট এবং স্টপ পজিশন বলা হয়।
মজার বিষয় হ'ল আপনি একবারে একাধিক বাক্স প্রতিস্থাপন করতে পারেন। এছাড়াও আপনি যেখানে চান সেখানে একাধিক বাক্স রাখতে পারেন।
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 () আউট সূচকের যা পরিসংখ্যান পাবেন। পাইথনে লজিক্যাল সমতুল্য কোডটি এখানে।
এই ফাংশনটি কাটা জন্য পাইথন অবজেক্ট এবং optionচ্ছিক পরামিতিগুলি গ্রহণ করে এবং অনুরোধ করা স্লাইসের জন্য প্রারম্ভ, স্টপ, পদক্ষেপ এবং স্লাইস দৈর্ঘ্য প্রদান করে।
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: সর্বশেষ সূচক, দ্রষ্টব্য যে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. অসুবিধা
উপরের অংশটি স্লাইস কীভাবে কাজ করে তার মূল বৈশিষ্ট্যগুলি ব্যাখ্যা করে এবং এটি বেশিরভাগ অনুষ্ঠানে কাজ করবে। তবে, আপনার লক্ষ্য করা উচিত এমন সমস্যাগুলি হতে পারে এবং এই অংশটি তাদের ব্যাখ্যা করে।
নেতিবাচক সূচকগুলি
পাইথন শিক্ষার্থীদের প্রথম যে বিষয়টি বিভ্রান্ত করে তা হ'ল একটি সূচকটি নেতিবাচক হতে পারে! আতঙ্কিত হবেন না: একটি নেতিবাচক সূচক মানে পিছনের দিকে গণনা।
উদাহরণ স্বরূপ:
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].নেতিবাচক পদক্ষেপ
জিনিসগুলি আরও বিভ্রান্তিকর করে তোলা তা stepনেতিবাচকও হতে পারে!
একটি নেতিবাচক পদক্ষেপের অর্থ অ্যারেটি পিছনের দিকে পুনরুক্তি করা: শেষ সূচকটি অন্তর্ভুক্ত সহ শুরু থেকে শুরু করা এবং সূচনা সূচকটি ফলাফল থেকে বাদ দেওয়া।
দ্রষ্টব্য : যখন পদক্ষেপটি নেতিবাচক হয় তখন এর ডিফল্ট মান 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পূর্ববর্তী উত্তরগুলি বহু-মাত্রিক অ্যারে স্লাইসিংয়ের বিষয়ে আলোচনা করে না যা বিখ্যাত নুমপি প্যাকেজটি ব্যবহার করে সম্ভব :
স্লাইসিং বহু-মাত্রিক অ্যারেতেও প্রয়োগ করা যেতে পারে।
# 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" পরে কমা দ্বিতীয় মাত্রা উপর কাজ করে।
listকেবলমাত্র arrayনম্পিতে
#!/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]নেতিবাচক পদক্ষেপ ব্যবহার করার সময়, লক্ষ্য করুন যে উত্তরটি 1 দ্বারা ডানদিকে সরানো হয়েছে।
আমার মস্তিষ্কটি থিম আইটেমটি lst[start:end]ধারণ করে তা গ্রহণ করে খুশি মনে হয় start। আমি এমনকি বলতে পারি যে এটি একটি 'প্রাকৃতিক অনুমান'।
তবে মাঝেমধ্যে একটি সন্দেহ চূড়ান্ত হয় এবং আমার মস্তিস্ক এই আশ্বাসের জন্য অনুরোধ করে যে এটিতে endতৃতীয় উপাদান নেই।
এই মুহুর্তগুলিতে আমি এই সাধারণ উপপাদ্যের উপর নির্ভর করি:
for any n, lst = lst[:n] + lst[n:]এই সুন্দর সম্পত্তিটি আমাকে বলে যে lst[start:end]এতে endথম আইটেমটি নেই কারণ এটি রয়েছে lst[end:]।
মনে রাখবেন যে এই উপপাদ্যটি যে কোনও ক্ষেত্রেই সত্য n। উদাহরণস্বরূপ, আপনি এটি পরীক্ষা করতে পারেন
lst = range(10)
lst[:-42] + lst[-42:] == lstআয় True।
আমার মতে, আপনি পাইথন স্ট্রিংয়ের স্লাইসিং নোটেশনটি আরও ভালভাবে বুঝতে এবং মুখস্থ করতে পারবেন যদি আপনি নীচের উপায়ে এটি পড়েন (পড়ুন)।
আসুন নিম্নলিখিত স্ট্রিংয়ের সাথে কাজ করুন ...
azString = "abcdefghijklmnopqrstuvwxyz"যারা জানেন না তাদের জন্য, আপনি azStringস্বরলিপিটি ব্যবহার করে কোনও স্ট্রিং তৈরি করতে পারেনazString[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], কারণ "গ" এর বাম দিকে সূচকটি 2 এবং "এইচ" এর ডান আকারের একটি 8 হয়।
মনে রাখবেন আমরা সীমানা নির্ধারণ করছি। এবং এই সীমানাগুলি হল এমন অবস্থান যেখানে আপনি কিছু বন্ধনী স্থাপন করতে পারতেন যা স্ট্রিংয়ের চারপাশে এভাবে জড়িয়ে থাকবে ...
ab [ cdefgh ] ij
এই কৌশলটি সর্বদা কাজ করে এবং মুখস্ত রাখা সহজ is
পূর্ববর্তী উত্তরগুলির বেশিরভাগগুলি স্লাইস নোটেশন সম্পর্কিত প্রশ্নগুলি সাফ করে।
টুকরো টুকরো করার জন্য ব্যবহৃত বর্ধিত সূচক বাক্য গঠন 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]মনে রাখবেন যে সংগ্রহটি কাটানোর ফলাফলটি সম্পূর্ণ নতুন সংগ্রহ। এছাড়াও, অ্যাসাইনমেন্টগুলিতে স্লাইস নোটেশন ব্যবহার করার সময়, স্লাইস অ্যাসাইনমেন্টগুলির দৈর্ঘ্য একই হওয়ার দরকার নেই। নির্ধারিত স্লাইসের আগে এবং পরে মানগুলি রাখা হবে এবং সংগ্রহটি সঙ্কুচিত হবে বা নতুন মানগুলি ধারণ করবে:
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]ব্যবহার stepএকটি দরকারী কৌতুক প্রদান করে পাইথন মধ্যে একটি সংগ্রহ বিপরীত:
In [25]: l[::-1]
Out[25]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]stepনিম্নলিখিত উদাহরণ হিসাবে নেতিবাচক পূর্ণসংখ্যার ব্যবহার করাও সম্ভব :
In[28]: l[::-2]
Out[28]: [9, 7, 5, 3, 1]তবে এর জন্য নেতিবাচক মান ব্যবহার করা stepখুব বিভ্রান্তিকর হয়ে উঠতে পারে। তাছাড়া, যাতে হতে হবে Pythonic , আপনি ব্যবহার এড়িয়ে চলা উচিত start, endএবং stepএকটি একক ফালি হবে। যদি এটির প্রয়োজন হয়, দুটি কার্য (এটির একটি টুকরো টুকরো এবং অন্যটি পদক্ষেপে) করার জন্য এটি বিবেচনা করুন।
In [29]: l = l[::2] # This step is for striding
In [30]: l
Out[30]: [0, 2, 4, 6, 8]
In [31]: l = l[1:-1] # This step is for slicing
In [32]: l
Out[32]: [2, 4, 6]আমি একটি যুক্ত করতে চাই হ্যালো, ওয়ার্ল্ড! উদাহরণস্বরূপ যে খুব নতুনদের জন্য স্লাইসের বেসিকগুলি ব্যাখ্যা করে। এটা আমাকে অনেক সাহায্য করেছে।
ছয়টি মান সহ একটি তালিকা আছে ['P', 'Y', 'T', 'H', 'O', 'N']:
+---+---+---+---+---+---+
| P | Y | T | H | O | N |
+---+---+---+---+---+---+
0 1 2 3 4 5এখন সেই তালিকার সরলতম স্লাইসগুলি হ'ল এর সাবলিস্ট। স্বরলিপিটি হ'ল [<index>:<index>]এবং কীটি এটির মতো পড়তে হবে:
[ start cutting before this index : end cutting before this index ]এখন আপনি [2:5]উপরের তালিকার টুকরোটি তৈরি করেন, এটি ঘটবে:
| |
+---+---|---+---+---|---+
| P | Y | T | H | O | N |
+---+---|---+---+---|---+
0 1 | 2 3 4 | 5আপনি একটি কেটে তৈরি আগে সূচকের সাথে উপাদান 2এবং অন্য কাটা সামনে সূচকের সাথে উপাদান 5। সুতরাং ফলাফল এই দুটি কাটা মধ্যে একটি টুকরা হবে, একটি তালিকা ['T', 'H', 'O']।
নীচে একটি স্ট্রিংয়ের সূচকের উদাহরণ:
+---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0 1 2 3 4 5
-5 -4 -3 -2 -1
str="Name string"কাটা উদাহরণ: [শুরু: শেষ: পদক্ষেপ]
str[start:end] # Items start through end-1
str[start:] # Items start through the rest of the array
str[:end] # Items from the beginning through end-1
str[:] # A copy of the whole arrayনীচে উদাহরণ ব্যবহার:
print str[0] = N
print str[0:2] = Na
print str[0:7] = Name st
print str[0:7:2] = Nm t
print str[0:-1:2] = Nm tiআপনি যদি স্লাইসিংয়ের ক্ষেত্রে নেতিবাচক সূচকগুলি বিভ্রান্তিমূলক মনে করেন তবে এখানে এটি সম্পর্কে চিন্তা করার খুব সহজ উপায়: কেবলমাত্র নেতিবাচক সূচকটি এর সাথে প্রতিস্থাপন করুন len - index। সুতরাং উদাহরণস্বরূপ, -3 এর সাথে প্রতিস্থাপন করুন len(list) - 3।
অভ্যন্তরীণভাবে স্লাইসিং কী করে তা চিত্রিত করার সর্বোত্তম উপায়টি কেবল কোডটিতে প্রদর্শিত হওয়া যা এই ক্রিয়াকলাপটি কার্যকর করে:
def slice(list, start = None, end = None, step = 1):
# Take care of missing start/end parameters
start = 0 if start is None else start
end = len(list) if end is None else end
# Take care of negative start/end parameters
start = len(list) + start if start < 0 else start
end = len(list) + end if end < 0 else end
# Now just execute a for-loop with start, end and step
return [list[i] for i in range(start, end, step)]স্লাইসিংয়ের বেসিক টেকনিকটি হ'ল স্টার্টিং পয়েন্ট, স্টপিং পয়েন্ট এবং স্টেপ সাইজ - যা স্ট্রাইড নামেও পরিচিত def
প্রথমত, আমরা আমাদের স্লাইসিংয়ে ব্যবহার করার জন্য মানগুলির একটি তালিকা তৈরি করব।
স্লাইস করতে দুটি তালিকা তৈরি করুন। প্রথমটি 1 থেকে 9 (তালিকা এ) এর একটি সংখ্যার তালিকা। দ্বিতীয়টি 0 থেকে 9 (তালিকার বি) পর্যন্ত একটি সংখ্যার তালিকাও রয়েছে:
A = list(range(1, 10, 1)) # Start, stop, and step
B = list(range(9))
print("This is List A:", A)
print("This is List B:", B)এ থেকে 3 নম্বর এবং বি থেকে 6 নম্বর সূচী করুন
print(A[2])
print(B[6])বেসিক স্লাইসিং
টুকরো টুকরো করার জন্য ব্যবহৃত বর্ধিত সূচীকরণ সিনট্যাক্স হ'ল তালিকা [শুরু: থামুন: পদক্ষেপ]। প্রারম্ভিক আর্গুমেন্ট এবং ধাপ যুক্তি উভয়ই ডিফল্ট নয় - কেবলমাত্র প্রয়োজনীয় যুক্তিটি স্টপ stop আপনি কি লক্ষ্য করেছেন যে কীভাবে এ এবং বি তালিকা সংজ্ঞায়িত করতে ব্যাপ্তি ব্যবহৃত হয়েছিল? এর কারণ স্লাইস অবজেক্ট পরিসীমা দ্বারা নির্দিষ্ট সূচকগুলির সেটকে উপস্থাপন করে (শুরু, থামান, পদক্ষেপ)। পাইথন ৩.৪ ডকুমেন্টেশন।
আপনি দেখতে পাচ্ছেন, কেবল স্টপ সংজ্ঞায়িত করে একটি উপাদান দেয়। যেহেতু শুরুটি ডিফল্ট নয় কারও কাছে এটি কেবলমাত্র একটি উপাদান পুনরুদ্ধারে অনুবাদ করে।
এটা খেয়াল করা জরুরী গুরুত্বপূর্ণ, প্রথম উপাদান ইনডেক্স 0, হয় না সূচক 1. এই কারণে আমরা এই ব্যায়াম 2 তালিকা ব্যবহার করছেন। তালিকার এগুলির উপাদানগুলি অর্ডিনাল পজিশন অনুসারে গণনা করা হয় (প্রথম উপাদানটি 1, দ্বিতীয় উপাদানটি 2, ইত্যাদি) এবং তালিকা বি এর উপাদানগুলি এমন সংখ্যা যা তাদের সূচকগুলিতে ব্যবহার করতে হবে ([0] প্রথম উপাদান 0, ইত্যাদি)।
বর্ধিত সূচীকরণ সিনট্যাক্স সহ, আমরা মানগুলির একটি ব্যাপ্তি পুনরুদ্ধার করি। উদাহরণস্বরূপ, সমস্ত মান একটি কোলন দিয়ে পুনরুদ্ধার করা হয়।
A[:]উপাদানগুলির একটি উপসেট পুনরুদ্ধার করতে, শুরু এবং স্টপ অবস্থানগুলি সংজ্ঞায়িত করা দরকার।
AList [শুরু: থামুন] প্যাটার্নটি দেওয়া, তালিকা এ থেকে প্রথম দুটি উপাদান পুনরুদ্ধার করুন
আমি মনে করি না পাইথন টিউটোরিয়াল ডায়াগ্রামটি (অন্যান্য বিভিন্ন উত্তরে উদ্ধৃত) ভাল কারণ এই পরামর্শটি ধনাত্মক অগ্রগতির জন্য কাজ করে তবে এটি নেতিবাচক পদক্ষেপের জন্য নয়।
এটি চিত্রটি:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
ডায়াগ্রাম থেকে, আমি আশা a[-4,-6,-1]করা yPকিন্তু এটা ty।
>>> a = "Python"
>>> a[2:4:1] # as expected
'th'
>>> a[-4:-6:-1] # off by 1
'ty'অক্ষর বা স্লটগুলিতে চিন্তা করা এবং অর্ধ-খোলা ব্যবধান হিসাবে সূচি ব্যবহার করা - সর্বদা কাজটি হ'ল ধনাত্মক অগ্রগতি হলে ডান-ওপেন, নেতিবাচক স্ট্রাইড হলে বাম-খোলা।
এইভাবে, আমি বিরতি পরিভাষা a[-4:-6:-1]হিসাবে হিসাবে চিন্তা করতে পারেন a(-6,-4]।
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
+---+---+---+---+---+---+---+---+---+---+---+---+
| P | y | t | h | o | n | P | y | t | h | o | n |
+---+---+---+---+---+---+---+---+---+---+---+---+
-6 -5 -4 -3 -2 -1 0 1 2 3 4 5