python পাইথন এর স্লাইস উল্লেখ বুঝতে




পাইথন প্রোগ্রামিং বই pdf (24)

সাধারণ নিয়ম হিসাবে, হার্ডকোডেড ইন্ডেক্স মানের অনেকগুলি কোড লেখা একটি পঠনযোগ্যতা এবং রক্ষণাবেক্ষণ জগাখিচুড়ি সৃষ্টি করে। উদাহরণস্বরূপ, আপনি যদি এক বছরের পরে কোডটিতে ফিরে আসেন, তবে আপনি এটি দেখবেন এবং আপনি যখন এটি লিখেছিলেন তখন কী ভাবছেন তা অবাক হবেন। দেখানো সমাধান কেবল আপনার কোড আসলে কি করছে আরো স্পষ্টভাবে একটি উপায়। সাধারণভাবে, বিল্ট-ইন স্লাইস () একটি স্লাইস অবজেক্ট তৈরি করে যা যে কোনও স্থানে একটি স্লাইস অনুমোদিত হতে পারে। উদাহরণ স্বরূপ:

>>> 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
>>>

পাইথনের স্লাইস নোটেশনে আমার একটি ভাল ব্যাখ্যা দরকার (রেফারেন্সগুলি প্লাস)।

আমার কাছে, এই নোট picking আপ একটি বিট প্রয়োজন।

এটা অত্যন্ত শক্তিশালী দেখায়, কিন্তু আমি বেশ কাছাকাছি আমার মাথা পেয়েছিলাম না।


আপনি তালিকা থেকে এক বা একাধিক উপাদান মুছে ফেলার জন্য স্লাইস অ্যাসাইনমেন্ট ব্যবহার করতে পারেন:

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

পাইথন 2.7

পাইথন মধ্যে slicing

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)

সূচক নিয়োগ বুঝতে খুব গুরুত্বপূর্ণ।

[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).

আপনি যখন [a: b: c] বলবেন, আপনি সি (এগিয়ে বা পশ্চাদ্ধাবন) এর চিহ্নের উপর নির্ভর করে বলছেন, বি এ শুরু করুন এবং বি এ শেষ করুন (বিথ ইন্ডেক্সে উপাদান বাদে)। উপরে সূচী নিয়ম ব্যবহার করুন এবং মনে রাখবেন আপনি শুধুমাত্র এই পরিসরের উপাদানগুলি খুঁজে পাবেন:

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

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

কিন্তু এই পরিসীমা সীমাহীনভাবে উভয় দিক চলতে থাকে:

-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 , ....

যদি A, B, এবং C এর আপনার পছন্দের উপরে আপনি যদি A, B, C এর জন্য নিয়মগুলি ব্যবহার করে ট্রাভস করে উপরের সীমারেখাটিকে ওভারল্যাপ করতে সক্ষম হন তবে আপনি উপাদানগুলির সাথে একটি তালিকা পাবেন (ট্র্যাভেরসালের সময় স্পর্শ) অথবা আপনি একটি খালি তালিকা পাবেন।

এক শেষ জিনিস: যদি A এবং B সমান হয়, তবে আপনি একটি খালি তালিকা পাবেন:

             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

আমার মস্তিষ্ক যে 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


আপনি যদি slicing মধ্যে নেতিবাচক সূচকগুলি বিভ্রান্তিকর মনে করেন, এটি সম্পর্কে চিন্তা করার একটি খুব সহজ উপায়: কেবল নেতিবাচক সূচীকে প্রতিস্থাপন করুন len - index। তাই উদাহরণস্বরূপ, -3 সঙ্গে প্রতিস্থাপন len(list) - 3

Slicing অভ্যন্তরীণভাবে কি চিত্রিত করার সবচেয়ে ভাল উপায় শুধু এই কোড প্রয়োগ করা হয় যে এই অপারেশন প্রয়োগ:

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 for-loop with start, end and step
  return [list[i] for i in range(start, end, step)]

উপরের বেশিরভাগ উত্তরগুলি স্লাইস নোটেশন সম্পর্কে সাফ করে। Slicing জন্য ব্যবহৃত বর্ধিত সূচক সিনট্যাক্স aList[start:stop:step]মৌলিক উদাহরণ হয়

:

আরো slicing উদাহরণ: 15 বর্ধিত স্লাইসেস


একটি পুনরাবৃত্তিযোগ্য (একটি তালিকা মত) নির্দিষ্ট টুকরা পেতে, এখানে একটি উদাহরণ:

variable[number1:number2]

এই উদাহরণে, নম্বর 1 এর জন্য একটি ইতিবাচক সংখ্যাটি আপনি সামনে কতগুলি অংশ নিচ্ছেন। একটি নেতিবাচক সংখ্যা সঠিক বিপরীত, আপনি কত থেকে শেষ রাখা। সংখ্যা 2 এর জন্য একটি ইতিবাচক সংখ্যা নির্দেশ করে যে আপনি কতগুলি উপাদান শুরু থেকে রাখতে চান এবং একটি নেতিবাচক তা হল যে আপনি কতটুকু শেষ থেকে বন্ধ করতে চান। এটি কিছুটা সহজে পাল্টা যুক্তিযুক্ত, তবে আপনি মনে রাখবেন যে তালিকা slicing অত্যন্ত দরকারী।


নীচের একটি স্ট্রিং সূচী উদাহরণ

 +---+---+---+---+---+
 | H | e | l | p | A |
 +---+---+---+---+---+
 0   1   2   3   4   5
-5  -4  -3  -2  -1

str="Name string"

slicing উদাহরণ: [শুরু: শেষ: ধাপ]

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

স্লাইস : - আপনার পায়ের কাছে সাপ প্রদর্শিত হয়। এটা দৃশ্যমান থেকে অদৃশ্য থেকে সরানো। আমাদের দৃষ্টি প্রকাশ করে (একটি স্লাইস মত) বিশ্বের শুধুমাত্র একটি অংশ। একইভাবে একটি পাইথন স্লাইস একটি শুরু এবং স্টপ উপর ভিত্তি করে উপাদান, নিষ্কাশন। আমরা পাইথন বিভিন্ন ধরনের উপর টুকরা নিতে। আমরা একটি ঐচ্ছিক প্রথম সূচক, একটি ঐচ্ছিক সর্বশেষ সূচক, এবং একটি ঐচ্ছিক পদক্ষেপ উল্লেখ।

values[1:3]  Index 1 through index 3.
values[2:-1] Index 2 through index one from last.
values[:2]   Start through index 2.
values[2:]   Index 2 through end.
values[::2]  Start through end, skipping ahead 2 places each time.

আপনি নীচের লিঙ্কে ভাল উদাহরণ পেতে পারেন: - পাইথন স্লাইস উল্লেখ উদাহরণ


প্রাথমিক স্লাইসিং টেকনিকটি প্রাথমিক বিন্দু, স্টপিং পয়েন্ট, এবং ধাপের আকার নির্ধারণ করতে হয় - যা স্ট্রাইড হিসাবেও পরিচিত।

প্রথমত, আমরা আমাদের slicing ব্যবহার করার মানগুলির একটি তালিকা তৈরি করব।

ফাঁকা দুটি তালিকা তৈরি করুন, প্রথমটি 1 থেকে 9 (তালিকা A) থেকে সংখ্যাসূচক তালিকা। দ্বিতীয়টি একটি সংখ্যাসূচক তালিকা, 0 থেকে 9 (তালিকা বি) থেকে

A = list(range(1,10,1)) # start,stop,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])

বেসিক slicing

Slicing জন্য ব্যবহৃত বর্ধিত সূচী সিনট্যাক্স aist [শুরু: স্টপ: পদক্ষেপ]। শুরু যুক্তি এবং ধাপে যুক্তি উভয়ই ডিফল্ট - শুধুমাত্র প্রয়োজনীয় যুক্তি থামানো হয়। আপনি কি লক্ষ্য করেছেন যে এটি কীভাবে A এবং B তালিকা সংজ্ঞায়িত করতে ব্যবহৃত হয়েছিল? এই কারণ হল স্লাইস বস্তু পরিসীমা দ্বারা নির্ধারিত সূচকগুলির সেটকে উপস্থাপন করে (শুরু, বন্ধ, ধাপ)। পাইথন 3.4 ডকুমেন্টেশন

আপনি দেখতে পারেন, সংজ্ঞায়িত শুধুমাত্র একটি উপাদান ফিরে বন্ধ। যেহেতু শুরু থেকেই কেউ ডিফল্ট নয়, এটি কেবলমাত্র একটি উপাদান পুনরুদ্ধার করতে অনুবাদ করে।

এটি উল্লেখ্য গুরুত্বপূর্ণ, প্রথম উপাদানটি সূচক 0, সূচক নয়। এই কারণে আমরা এই অনুশীলনের জন্য 2 টি তালিকা ব্যবহার করছি। তালিকা A এর উপাদানগুলি ক্রমিক অবস্থার (প্রথম উপাদানটি 1, দ্বিতীয় উপাদানটি 2, ইত্যাদি) অনুসারে গণনা করা হয় তবে তালিকা বি এর উপাদানগুলি সেই সংখ্যা যা তাদের সূচকের জন্য (0 0) প্রথম উপাদান 0, ইত্যাদির জন্য ব্যবহার করা হবে। )।

বর্ধিত সূচী সিনট্যাক্স সঙ্গে, আমরা মান একটি পরিসীমা পুনরুদ্ধার। উদাহরণস্বরূপ, সমস্ত মান একটি কোলন সঙ্গে পুনরুদ্ধার করা হয়।

A[:]

উপাদানগুলির একটি উপসেট পুনরুদ্ধার করতে, শুরু এবং স্টপ অবস্থানগুলি সংজ্ঞায়িত করা প্রয়োজন।

প্যাটার্ন aist [শুরু: স্টপ] দেওয়া, তালিকা এ থেকে প্রথম দুটি উপাদান উদ্ধার


পাইথন এর স্লাইস নোট ব্যাখ্যা

সংক্ষেপে, সাবস্ক্রিপশন নোটেশন ( subscriptable[subscriptarg] ) এ কলোনগুলি (:) স্লাইস নোটেশন তৈরি করে - যার মধ্যে ঐচ্ছিক আর্গুমেন্ট রয়েছে, start , stop , step :

sliceable[start:stop:step]

পাইথন slicing পদ্ধতিগতভাবে আপনার তথ্য অংশ অ্যাক্সেস করার জন্য একটি computationally দ্রুত উপায়। আমার মতে, এমনকি একটি মধ্যবর্তী পাইথন প্রোগ্রামার হওয়া, এটি এমন একটি ভাষা যা এটি পরিচিত হওয়া দরকার।

গুরুত্বপূর্ণ সংজ্ঞা

শুরু করতে, এর কয়েকটি শর্ত সংজ্ঞায়িত করা যাক:

শুরু করুন: স্লাইসের সূচী সূচী, এটি সূচীর এটিকে অন্তর্ভুক্ত করবে যতক্ষণ না এটি স্টপের মতো , 0 ডিফল্ট, অর্থাৎ প্রথম সূচী। এটি নেতিবাচক, এটি শেষ থেকে n আইটেম শুরু মানে।

বন্ধ করুন: স্লাইসের শেষ সূচক, এটি এই সূচীতে উপাদানটি অন্তর্ভুক্ত করে না , ক্রমানুসারে ক্রমানুসারে ক্রমানুসার দৈর্ঘ্যের ডিফল্ট, যা শেষ পর্যন্ত এবং শেষ সহ।

ধাপ: সূচকটি যে পরিমাণে বৃদ্ধি পায়, তা ডিফল্ট করে 1. যদি এটি নেতিবাচক হয়, তবে আপনি বিপরীত দিকে পুনরাবৃত্তির উপর slicing করছেন।

কিভাবে সূচক কাজ করে

আপনি এই ইতিবাচক বা নেতিবাচক সংখ্যা কোন করতে পারেন। ইতিবাচক সংখ্যার অর্থটি সরল, কিন্তু নেতিবাচক সংখ্যার জন্য, পাইথন সূচীগুলির মতোই, আপনি শুরু থেকে শুরু করতে এবং বন্ধের জন্য পূর্বের দিকে গণনা করেন এবং পদক্ষেপের জন্য আপনি কেবল আপনার সূচী হ্রাস করেন। এই উদাহরণটি ডকুমেন্টেশনের টিউটোরিয়াল থেকে , তবে আমি প্রতিটি সংশোধনী অনুসারে কোন আইটেমটি নির্দেশ করে তা সামান্য সংশোধন করেছি:

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

কিভাবে slicing কাজ

এটি সমর্থন করার জন্য একটি ক্রম সহ স্লাইস নোটেশন ব্যবহার করতে, আপনাকে অবশ্যই স্কোয়ার বন্ধনীগুলিতে কমপক্ষে একটি কলোন অন্তর্ভুক্ত করতে হবে যা ক্রম অনুসরণ করে (যা প্রকৃতপক্ষে ক্রম অনুসারে __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 জন্য ডিফল্ট পরিবর্তন stop !

উৎস এই নিশ্চিত করা

আমি ব্যবহারকারীদের উত্স এবং ডকুমেন্টেশন পড়তে উৎসাহিত করতে চাই। স্লাইস বস্তু এবং এই যুক্তি জন্য উৎস কোড এখানে পাওয়া যায়step আমরা নেতিবাচক কিনা তা নির্ধারণ করুন:

 step_is_negative = step_sign < 0;

যদি তাই হয়, নিম্ন আবদ্ধ -1 হল যার অর্থ আমরা শুরুতে এবং সহ সহ সমস্ত উপায়ে স্লাইস করি, এবং ঊর্ধ্ব আবদ্ধ দৈর্ঘ্য 1 হ্রাস, যার অর্থ আমরা শেষে শুরু করি। (উল্লেখ্য যে এই -1 এর সেমেন্টিক্স -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 জন্য ডিফল্টগুলি প্রয়োগ করতে stop - ডিফল্টের জন্য ডিফল্ট 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__ এটি প্রেরণ থেকে আলাদা করতে আলাদা করার জন্য এটি দরকারী খুঁজে পেতে পারেন 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 সম্পর্কে সচেতন হতে পারে। সাধারণত আপনি একটি টুকরা উপর পুনরাবৃত্তি করতে চান, এটি মেমরির মধ্যে staticically নির্মিত না। islice জন্য নিখুঁত। একটি ক্যাভিট, এটি নেতিবাচক আর্গুমেন্টগুলিকে start , stop বা step সমর্থন করে না, তাই এটি যদি কোনও সমস্যা হয় তবে আপনাকে সূচকগুলি গণনা করতে বা অগ্রগতিতে অগ্রসর হওয়ার প্রয়োজন হতে পারে।

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]

তালিকা স্লিপ একটি কপি করা যে তালিকা নিজেই একটি বৈশিষ্ট্য। আপনি যদি কোনও প্যান্ডাস ডাটাফ্রেমের মতো উন্নত বস্তুগুলিকে টাস্ক করছেন তবে এটি একটি অনুলিপিটি অনুলিপি করা যাবে এবং একটি অনুলিপি নয়।


পাইথন slicing নোটেশন:

a[start:end:step]
  • start এবং end , নেতিবাচক মান ক্রম শেষে আপেক্ষিক হিসাবে ব্যাখ্যা করা হয়।
  • end জন্য ইতিবাচক সূচক শেষ উপাদান অন্তর্ভুক্ত করার পরে অবস্থান নির্দেশ করে।
  • নিম্নমানের মান নিম্নরূপ ডিফল্ট হয়: [+0:-0:1]
  • একটি নেতিবাচক পদক্ষেপ ব্যবহার start এবং end ব্যাখ্যা বিপরীত

বিবৃতি matrix এবং multidimensional অ্যারে (numpy) প্রসারিত। উদাহরণস্বরূপ, পুরো কলামের টুকরো টুকরো করার জন্য আপনি ব্যবহার করতে পারেন:

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

স্লাইসগুলি অ্যারের উপাদানের রেফারেন্সগুলি ধারণ করে, কপি নয়। আপনি একটি অ্যারে একটি আলাদা কপি করতে চান, আপনি গভীর কপি deepcopy() ব্যবহার করতে পারেন।


আমি একটি হ্যালো বিশ্ব উদাহরণ যুক্ত করতে চাই যা খুব নতুনদের জন্য স্লাইসগুলির বুনিয়াদি ব্যাখ্যা করে। এটা আমাকে অনেক সাহায্য করেছে।

চলুন ছয়টি মান নিয়ে একটি তালিকা আছে ['P', 'Y', 'T', 'H', 'O', 'N']:

+---+---+---+---+---+---+
| P | Y | T | H | O | N |
+---+---+---+---+---+---+
  0   1   2   3   4   5 

এখন সেই তালিকার সর্বাধিক টুকরা তার sublists হয়। নোটেশন [<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']


উপরে উত্তর slice অ্যাসাইনমেন্ট আলোচনা করবেন না। স্লাইস অ্যাসাইনমেন্ট বোঝার জন্য, অ্যাসিচি শিল্পে অন্য ধারণা যোগ করা সহায়ক:

                +---+---+---+---+---+---+
                | 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']

এক হিউরিস্টিক হ'ল শূন্য থেকে 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.

স্লাইস অ্যাসাইনমেন্টের প্রথম নিয়ম হল যে slicing একটি তালিকা প্রদান করে, স্লাইস অ্যাসাইনমেন্টের জন্য একটি তালিকা (বা অন্য পুনরাবৃত্তিযোগ্য) প্রয়োজন:

>>> 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']

Trickiest অংশ ফাঁকা টুকরা বরাদ্দ করা ব্যবহার করা হয়। হিউরিস্টিক 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]
 []

এবং তারপর আপনি যে একবার দেখেছেন, ফাঁকা ফালি slice নিয়োগ খুব জ্ঞান করে তোলে:

>>> 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'] # result is longer
>>> p = ['P','y','t','h','o','n']
>>> p[4:4] = ['x','y']
>>> p
 ['P','y','t','h','x','y','o','n'] # result is longer still

মনে রাখবেন, যেহেতু আমরা স্লাইস (4) এর দ্বিতীয় সংখ্যা পরিবর্তন করছি না, তাই সন্নিবেশকৃত আইটেমগুলি সর্বদা 'o' এর বিরুদ্ধে ঠিক আছে, এমনকি আমরা খালি ফাঁকা অংশটি নিযুক্ত করার পরেও। তাই ফাঁকা ফাঁকা বরাদ্দকরণের অবস্থান নন-ফাঁকা ফাঁকা বরাদ্দকরণের অবস্থানগুলির লজিক্যাল এক্সটেনশান।

সামান্য বিট আপ, আপনি কি স্লাইস শুরু গণনা আমাদের মিছিল সঙ্গে চলতে যখন কি হবে?

>>> 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]
 []

Slicing সঙ্গে, একবার আপনি সম্পন্ন, আপনি সম্পন্ন করা হয়; এটা পিছনে slicing শুরু হয় না। পাইথনগুলিতে আপনি নেতিবাচক অগ্রগতি পাবেন না যদি না আপনি একটি নেতিবাচক নম্বর ব্যবহার করে তাদের জন্য স্পষ্টভাবে জিজ্ঞাসা করেন।

>>> 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

প্রকৃতপক্ষে, সূচী তুলনায়, পাইথন slicing বিজোড় ত্রুটি-প্রমাণ:

>>> 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=[0,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]

এই slicing এবং সূচকের মধ্যে পার্থক্য ব্যাখ্যা করতে পারে।


আমি নিজের সম্পর্কে চিন্তা করার পদ্ধতিগুলির "উপাদানগুলির মধ্যে একটি সূচক বিন্দু" পদ্ধতি ব্যবহার করি, কিন্তু এটি বর্ণনা করার এক উপায় যা কখনও কখনও অন্যদের এটি পেতে সহায়তা করে:

mylist[X:Y]

এক্স আপনি চান প্রথম উপাদান সূচক।
Y হল এমন প্রথম উপাদান যা আপনি চান না


এটি ব্যবহার করার পরে একটু বুঝতে পারলাম যে সর্বাধিক বর্ণনাটি হল যে এটি লুপের জন্য আর্গুমেন্টের মতোই ...

(from:to:step)

তাদের কোন ঐচ্ছিক

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

তারপরে নেতিবাচক সূচীটি আপনাকে বোঝার জন্য নেতিবাচক সূচকগুলিতে স্ট্রিংটির দৈর্ঘ্য যুক্ত করতে হবে।

এটা যেভাবে আমার জন্য কাজ করে ...


এবং প্রথম জিনিসটি যখন আমি প্রথম স্লাস্টিং সিনট্যাক্স দেখেছিলাম তখন আমার কাছে কিছুটা স্পষ্ট ছিল না:

>>> 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]

আমি newbies থেকে টুকরা শেখান কিভাবে:

সূচী এবং slicing মধ্যে পার্থক্য বোঝা:

উইকি পাইথন এই আশ্চর্যজনক ছবি যা স্পষ্টভাবে ইন্ডেক্সিং এবং slicing প্রভেদ আছে।

এটা 6 উপাদান সঙ্গে একটি তালিকা। ভাল slicing ভাল বুঝতে, ছয় বক্স এক সেট হিসাবে তালিকা যে তালিকা বিবেচনা। প্রতিটি বক্সে এটি একটি বর্ণমালা আছে।

সূচী বাক্সের বিষয়বস্তু সঙ্গে ডিল করা হয়। আপনি কোন বক্স বিষয়বস্তু পরীক্ষা করতে পারেন। কিন্তু আপনি একযোগে একাধিক বক্সের বিষয়বস্তু পরীক্ষা করতে পারবেন না। আপনি এমনকি বক্স বিষয়বস্তু প্রতিস্থাপন করতে পারেন। কিন্তু আপনি 1 বক্সে 2 টি বাজানো বা একবারে 2 বল প্রতিস্থাপন করতে পারবেন না।

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

Slicing বক্স নিজেই সঙ্গে ডিল করা হয়। আপনি প্রথম বাক্সে পিকআপ করতে পারেন এবং অন্য টেবিলে রাখতে পারেন। বক্সটি পিকআপ করতে আপনাকে যা জানা দরকার তা হল বাক্সের শুরু ও সমাপ্তির অবস্থান।

আপনি এমনকি প্রথম 3 বক্স বা শেষ 2 বক্স বা 1 এবং 4 এর মধ্যে সমস্ত বাক্সে পিকআপ করতে পারেন। সুতরাং আপনি যদি শুরু এবং সমাপ্তি জানেন তবে বাক্সের যে কোনও সেট চয়ন করতে পারেন। এই অবস্থানের শুরু এবং অবস্থান বন্ধ করা হয়।

আকর্ষণীয় জিনিস আপনি একযোগে একাধিক বক্স প্রতিস্থাপন করতে পারেন। এছাড়াও আপনি যেখানে আপনি চান একাধিক বক্স স্থাপন করতে পারেন।

>>> 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]

পদক্ষেপ সঙ্গে slicing:

এখন পর্যন্ত আপনি ক্রমাগত বক্স বাছাই করেছেন। কিন্তু কিছু বার আপনি discretely পিক আপ প্রয়োজন। উদাহরণস্বরূপ আপনি প্রতি সেকেন্ডে পিকআপ নিতে পারেন। আপনি এমনকি শেষ থেকে প্রতি তৃতীয় বাক্সে পিকআপ করতে পারেন। এই মান পদক্ষেপ আকার বলা হয়। এই আপনার ক্রমবর্ধমান pickups মধ্যে ফাঁক প্রতিনিধিত্ব করে। ধাপের আকারটি ইতিবাচক হওয়া উচিত যদি আপনি শুরু থেকে শেষ পর্যন্ত এবং শেষে বিপরীত দিক থেকে বাক্সগুলি বাছাই করেন।

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

কিভাবে পাইথন পরিসংখ্যান অনুপস্থিত পরামিতি আউট:

যখন আপনি কোনও প্যারামিটার ছাড়াই কাটছেন, তখন পাইথন স্বয়ংক্রিয়ভাবে এটি সনাক্ত করার চেষ্টা করে।

আপনি যদি CPython এর সোর্স কোডটি পরীক্ষা করেন, তবে আপনি পাইস্লাইস_গেট ইন্ডাইক্সএক্স নামক একটি ফাংশন পাবেন যা কোনও প্রদেয় প্যারামিটারগুলির জন্য একটি স্লাইসে সূচকগুলি চিহ্নিত করে। এখানে পাইথন মধ্যে লজিক্যাল সমতুল্য কোড।

এই ফাংশন slicing জন্য একটি পাইথন বস্তু এবং ঐচ্ছিক পরামিতি লাগে এবং অনুরোধকৃত স্লাইস জন্য শুরু, বন্ধ, ধাপ এবং ফাঁক দৈর্ঘ্য আয়।

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]: []

দ্রষ্টব্য: এই পোস্টটি মূলত আমার ব্লগে লেখা আছে http://www.avilpage.com/2015/03/a-slice-of-python-intelligence-behind.html


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


#!/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 দ্বারা ডান দিকে স্থানান্তরিত হয় লক্ষ্য করুন।


পাইথন ইন, slicing জন্য সবচেয়ে মৌলিক ফর্ম নিম্নলিখিত:

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]

শুরু থেকে slicing, আপনি শূন্য সূচী বাদ দিতে পারেন, এবং শেষ slicing যখন, আপনি চূড়ান্ত সূচক বাদ দিতে পারেন, কারণ এটি অকার্যকর, তাই verbose না:

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 3 elements
Out[8]: [7, 8, 9]

যেমন slicing যখন সীমার বাইরে হয় সূচক নির্দেশ প্রদান সম্ভব:

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

একটি সংগ্রহ slicing ফলাফল একটি সম্পূর্ণ নতুন সংগ্রহ মনে রাখবেন। উপরন্তু, বরাদ্দকরণগুলিতে স্লাইস নোটেশন ব্যবহার করার সময়, স্লাইস অ্যাসাইনমেন্টের দৈর্ঘ্য একই হতে হবে না। নির্ধারিত স্লাইসের আগে এবং পরে মানগুলি রাখা হবে এবং সংগ্রহটি নতুন মানগুলি সঙ্কুচিত বা হ্রাস পাবে:

In [16]: l[2:6] = list('abc') # assigning less 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', '.', '.', '.']

মৌলিক slicing ছাড়াও, নিম্নলিখিত নোট প্রয়োগ করা সম্ভব:

l[start:end:step]

যেখানে lএকটি সংগ্রহ, startএকটি অন্তর্ভুক্তি সূচক, endএকটি একচেটিয়া সূচক, এবং stepএকটি প্রান্ত যে প্রতিটি nth আইটেম গ্রহণ করতে ব্যবহার করা যেতে পারে 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]

এই দুর্দান্ত টেবিলে http://wiki.python.org/moin/MovingToPythonFromOtherLanguages পাওয়া গেছে

>>> 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]

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. Pitfalls

উপরের অংশটি কিভাবে স্লাইস কাজ করে তার মূল বৈশিষ্ট্যগুলি ব্যাখ্যা করে, এটি বেশিরভাগ ক্ষেত্রে কাজ করবে। যাইহোক আপনি pitfalls আউট দেখা উচিত, এবং এই অংশ তাদের ব্যাখ্যা করা হতে পারে।

নেতিবাচক সূচী

পাইথন শিখার প্রথম জিনিসটি বিভ্রান্তিকর যে সূচকটি নেতিবাচক হতে পারে! প্যানিক না: নেতিবাচক সূচক পিছনে থেকে গণনা মানে।

উদাহরণ স্বরূপ:

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

নেতিবাচক পদক্ষেপ

জিনিসগুলিকে আরও বিভ্রান্তিকর করে তুলুন যে step নেতিবাচক হতে পারে!

নেতিবাচক পদক্ষেপ মানে অ্যারে পিছন দিকে পুনরাবৃত্তি করা: শেষ থেকে শুরু করে, শেষ সূচী সহ, এবং ফলাফল থেকে বাদ দেওয়া শুরু সূচী।

উল্লেখ্য : যখন পদক্ষেপ নেতিবাচক হয়, জন্য ডিফল্ট মান startথেকে len(s)(যখন endসমান নয় 0, কারণ s[::-1]রয়েছে s[0])। উদাহরণ স্বরূপ:

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

পরিসীমা ত্রুটি আউট?

বিস্মিত হোন: সূচী পরিসীমা অতিক্রম করা হয় যখন টুকরা IndexError বাড়াতে না!

যদি সূচী সীমার বাইরে থাকে, তবে পাইথন সূচকের জন্য 0বা তার len(s)অনুসারে সূচকের সেরা সেটটি চেষ্টা করবে । উদাহরণ স্বরূপ:

s[:len(s)+5]      # same as s[:len(s)]
s[-len(s)-5::]    # same as s[0:]
s[len(s)+5::-1]   # same as s[len(s)::-1], 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, 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 IndexError
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-15-79ffc22473a3> in <module>()
----> 1 s[11]

IndexError: list index out of range

উপরের উত্তরগুলি বিখ্যাত নুপি প্যাকেজ ব্যবহার করে যা বহু-মাত্রিক অ্যারের স্লাইসিং নিয়ে আলোচনা করে না:

Slicing এছাড়াও বহু-মাত্রিক অ্যারে প্রযোজ্য।

# 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]])

কমাটি প্রথম মাত্রায় এবং "0: 3: 2" দ্বিতীয় বিন্যাসে কমা পরিচালনার পরে "2:" এর আগে।





slice