উত্তর:
আপনি reversedএটির জন্য এই ফাংশনটি ব্যবহার করতে পারেন :
>>> array=[0,10,20,40]
>>> for i in reversed(array):
... print(i)নোট যে reversed(...)একটি তালিকা ফেরত না। ব্যবহার করে আপনি বিপরীত তালিকা পেতে পারেন list(reversed(array))।
reverseযদিও এরপরে আপনাকে তালিকাতে কাস্ট করতে হবে না তবে দ্রুত হতে পারে।
reversed()টুকরো টুকরো করার পরিবর্তে কেন ব্যবহার করবেন ? পাইথনের জেন পড়ুন, নিয়ম সংখ্যা 7: পাঠযোগ্যতার গণনা!
>>> L = [0,10,20,40]
>>> L[::-1]
[40, 20, 10, 0]এক্সটেন্ডেড স্লাইস সিনট্যাক্সটি মুক্তির জন্য পাইথন নতুন কী এন্ট্রিতে ভালভাবে ব্যাখ্যা করা হয়েছে2.3.5
একটি মন্তব্যে বিশেষ অনুরোধে এটি সর্বাধিক বর্তমান স্লাইস ডকুমেন্টেশন ।
reversedএকটি listreverseiteratorবস্তু (পাইথন ২.7.x) প্রদান করে, যা এরপরে পুনরাবৃত্তি করতে হবে - বিপরীত স্লাইসিং একটি বিপরীত তালিকা / টুপল / স্ট্রিং (আপনি কী কাটাচ্ছেন তার উপর নির্ভর করে) প্রদান করে। @ ইয়নার পিটারসেন যে স্ট্রিংটিকে বিপরীত করছে, তাই আউটপুটটি সঠিক। চেষ্টা করুন:co2=['ae','ad','ac','ab','aa','z','y','x','w','v','u','t','s','r','q','p','o','n','m','l','k','j','i','h','g','f','e','d','c','b','a'] >>> co2[::-1]
>>> L = [0,10,20,40]
>>> L.reverse()
>>> L
[40, 20, 10, 0]অথবা
>>> L[::-1]
[40, 20, 10, 0]L=L[::-1]আসলে তালিকার বিপরীত হওয়া উচিত অন্যথায় আপনি কেবল মানগুলি বিপরীতে ফিরিয়ে দিচ্ছেন
b = l[-n:] b.reverse() l = b + l[:len(l) - n]
আমি মনে করি পাইথনে কোনও তালিকা উল্টানোর সর্বোত্তম উপায়টি হ'ল:
a = [1,2,3,4]
a = a[::-1]
print(a)
>>> [4,3,2,1]কাজ শেষ হয়েছে, এবং এখন আপনার বিপরীত তালিকা রয়েছে।
স্লাইসিং ব্যবহার করে, উদাহরণস্বরূপ অ্যারে = অ্যারে [:: - 1], একটি ঝরঝরে কৌশল এবং খুব পাইথোনিক, তবে সম্ভবত নবীনদের জন্য কিছুটা অস্পষ্ট। বিপরীত () পদ্ধতিটি ব্যবহার করে প্রতিদিন কোডিংয়ে যাওয়ার একটি ভাল উপায় কারণ এটি সহজেই পঠনযোগ্য।
তবে, যদি আপনাকে একটি সাক্ষাত্কার প্রশ্নের মতো জায়গায় কোনও তালিকা উল্টানো দরকার হয় তবে আপনি সম্ভবত এই জাতীয় পদ্ধতিতে অন্তর্নির্মিত ব্যবহার করতে সক্ষম হবেন না। সাক্ষাত্কারকারক আপনি কীভাবে পাইথন জ্ঞানের গভীরতার চেয়ে সমস্যার দিকে এগিয়ে যাবেন সেদিকে নজর রাখবেন, একটি অ্যালগরিদমিক পদ্ধতির প্রয়োজন। নিম্নলিখিত উদাহরণটি, ক্লাসিক অদলবদল ব্যবহার করে এটি করার এক উপায় হতে পারে: -
def reverse_in_place(lst): # Declare a function
size = len(lst) # Get the length of the sequence
hiindex = size - 1
its = size/2 # Number of iterations required
for i in xrange(0, its): # i is the low index pointer
temp = lst[hiindex] # Perform a classic swap
lst[hiindex] = lst[i]
lst[i] = temp
hiindex -= 1 # Decrement the high index pointer
print "Done!"
# Now test it!!
array = [2, 5, 8, 9, 12, 19, 25, 27, 32, 60, 65, 1, 7, 24, 124, 654]
print array # Print the original sequence
reverse_in_place(array) # Call the function passing the list
print array # Print reversed list
**The result:**
[2, 5, 8, 9, 12, 19, 25, 27, 32, 60, 65, 1, 7, 24, 124, 654]
Done!
[654, 124, 24, 7, 1, 65, 60, 32, 27, 25, 19, 12, 9, 8, 5, 2]নোট করুন যে এটি টিপলস বা স্ট্রিং সিকোয়েন্সগুলিতে কাজ করবে না, কারণ স্ট্রিং এবং টিপলগুলি অপরিবর্তনীয়, অর্থাৎ উপাদান পরিবর্তন করতে আপনি এগুলিতে লিখতে পারবেন না।
lst[hiindex], lst[i] = lst[i], lst[hiindex], আমি মনে করি ... ;-)
array[::-1]পুরোপুরি পাঠযোগ্য এবং পুরোপুরি স্পষ্ট হয় যদি আপনি পাইথন জানেন । "পঠনযোগ্য" এর অর্থ এই নয় যে "যে কেউ পাইথন স্লাইসিং এর আগে কখনও ব্যবহার করেন নি সে অবশ্যই এটি পড়তে সক্ষম হবে"; [::-1]reversing ফালি (আপনি যদি বিদ্যমান কোড সব সময় এটা সম্মুখীন করব) পাইথন একটি হাস্যকর সাধারণ বাগ্ধারা, এবং এটা পুরোপুরি পাঠযোগ্য এর যদি আপনি নিয়মিত পাইথন ব্যবহার । নিশ্চিত, first10 = [], for i in range(10): first10.append(array[i])স্পষ্ট এবং স্পষ্ট, কিন্তু এটি বেশী ভালো দেখা যায় না first10 = array[:10]।
l.reverse()পাইথন 3 এবং 2 এ লম্বা তালিকার বিপরীততমতমতমতম উপায়টি আমি (কিছু অন্যান্য পরামর্শের বিপরীতে) পাই others আমি জানতে আগ্রহী যে অন্যরা এই সময়গুলি প্রতিলিপি করতে পারে কিনা।
l[::-1]সম্ভবত এটি ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে কারণ এটি তালিকাটি উল্টানোর আগে অনুলিপি করে। list()দ্বারা করা পুনরাবৃত্তির চারপাশে কল যুক্ত করাতে reversed(l)অবশ্যই কিছু ওভারহেড যুক্ত করতে হবে। অবশ্যই যদি আপনি তালিকার অনুলিপি বা একটি পুনরুক্তি পেতে চান তবে সেই সম্পর্কিত পদ্ধতিগুলি ব্যবহার করুন, তবে আপনি যদি কেবল তালিকার বিপরীত করতে চান তবে l.reverse()দ্রুততম উপায় বলে মনে হয়।
ক্রিয়াকলাপ
def rev_list1(l):
return l[::-1]
def rev_list2(l):
return list(reversed(l))
def rev_list3(l):
l.reverse()
return lতালিকা
l = list(range(1000000))পাইথন 3.5 সময়
timeit(lambda: rev_list1(l), number=1000)
# 6.48
timeit(lambda: rev_list2(l), number=1000)
# 7.13
timeit(lambda: rev_list3(l), number=1000)
# 0.44পাইথন ২.7 সময়
timeit(lambda: rev_list1(l), number=1000)
# 6.76
timeit(lambda: rev_list2(l), number=1000)
# 9.18
timeit(lambda: rev_list3(l), number=1000)
# 0.46list.reverseদ্রুততম, কারণ এটি জায়গায়
list.reverse()দ্রুততম, তবে আপনি জরিমানা করছেন reversed(যা আপনি কোনও নতুন না চাইলে সবচেয়ে ভাল ব্যবহৃত হয় list, কেবল listআসলটি পরিবর্তন না করে কেবল কোনও বিপরীত ক্রমে পুনরাবৃত্তি করতে ), এবং স্লাইস (যা মূলটিকে পরিবর্তিত করতে এড়াতেও এড়ানো হয়) list, এবং reversedইনপুট ছোট হওয়ার চেয়ে সাধারণত দ্রুত হয়)। হ্যাঁ, যদি আপনার অনুলিপিটির প্রয়োজন না হয়, এমন কিছু যা অনুলিপি বেশি ব্যয়বহুল, তবে অনেক সময়, আপনি আসল মানটি পরিবর্তন করতে চান না।
reversed এখনও হারেlist.reverse() , তবে এটি ইনপুটটিকে রূপান্তরিত করে না list, এটি অনেক ক্ষেত্রেই ভাল better এর ক্ষতির পরিমাণ reversedখুব কম (~ 1/6 6th এর চেয়ে বেশি list.reverse())
>>> list1 = [1,2,3]
>>> reversed_list = list(reversed(list1))
>>> reversed_list
>>> [3, 2, 1]array=[0,10,20,40]
for e in reversed(array):
print eবিপরীত (অ্যারে) ব্যবহার করা সম্ভবত সেরা রাস্তা হবে।
>>> array = [1,2,3,4]
>>> for item in reversed(array):
>>> print itemবিল্ট ইন ব্যবহার না করে কীভাবে এটি বাস্তবায়ন করতে পারে তা আপনার বুঝতে হবে reversed।
def reverse(a):
midpoint = len(a)/2
for item in a[:midpoint]:
otherside = (len(a) - a.index(item)) - 1
temp = a[otherside]
a[otherside] = a[a.index(item)]
a[a.index(item)] = temp
return aএটিতে ও (এন) সময় নেওয়া উচিত।
যদি আপনি বিপরীত তালিকার উপাদানগুলিকে অন্য কিছু চলকতে সঞ্চয় করতে চান তবে আপনি ব্যবহার করতে পারেন revArray = array[::-1]বা revArray = list(reversed(array))।
তবে প্রথম রূপটি কিছুটা দ্রুত:
z = range(1000000)
startTimeTic = time.time()
y = z[::-1]
print("Time: %s s" % (time.time() - startTimeTic))
f = range(1000000)
startTimeTic = time.time()
g = list(reversed(f))
print("Time: %s s" % (time.time() - startTimeTic))আউটপুট:
Time: 0.00489711761475 s
Time: 0.00609302520752 stimeit।
পাইথনে, তালিকার অর্ডারটিও সংখ্যা অনুসারে / বর্ণানুক্রমিক ক্রমে আপনার ভেরিয়েবলগুলি সংগঠিত করে বাছাই করে সাজানো যায়:
print(sorted(my_list))my_list.sort(), print(my_list)আপনি পতাকাটি "বিপরীত = সত্য" দিয়ে বাছাই করতে পারেন :
print(sorted(my_list, reverse=True))অথবা
my_list.sort(reverse=True), print(my_list)
হতে পারে আপনি মানগুলি বাছাই করতে চান না, তবে কেবল মানগুলি বিপরীত করুন। তারপরে আমরা এটির মতো এটি করতে পারি:
print(list(reversed(my_list)))
** তালিকা ক্রম অনুযায়ী বর্ণমালার তুলনায় সংখ্যাগুলির অগ্রাধিকার রয়েছে। পাইথন মানগুলির সংগঠনটি দুর্দান্ত।
বেশ কয়েকটি ভাল উত্তর রয়েছে তবে ছড়িয়ে পড়ে এবং বেশিরভাগই প্রতিটি পদ্ধতির মৌলিক পার্থক্য নির্দেশ করে না।
সামগ্রিকভাবে, বিপরীতে বিল্ট-ইন ফাংশন / পদ্ধতিগুলি ব্যবহার করা আরও ভাল, ঠিক যেমন কোনও ফাংশন হিসাবে। এই ক্ষেত্রে, তারা শর্ট তালিকাগুলিতে (10 টি আইটেম) প্রায় 2 থেকে 8 গুণ বেশি দ্রুত এবং ম্যানুয়ালি সূচক তৈরির একটি মাধ্যম তৈরির তুলনায় দীর্ঘ তালিকায় ~ 300 + গুণ বেশি গতিযুক্ত। এগুলি তাদের তৈরি, যাচাই এবং অপ্টিমাইজেশান বিশেষজ্ঞ রয়েছে বলে এটি উপলব্ধি করে। এগুলি ত্রুটিগুলির প্রবণতাও কম এবং প্রান্ত এবং কোণার কেসগুলি পরিচালনা করার সম্ভাবনা বেশি।
আপনি চান কিনা তাও বিবেচনা করুন:
object[::-1]কভার করা পদ্ধতিগুলির জন্য এখানে আমার পরীক্ষার স্ক্রিপ্টের শুরু। এই উত্তরে সমস্ত কোড স্নিপেট একসাথে একটি স্ক্রিপ্ট তৈরি করুন যা প্রতিটি তালিকা এবং সময়কে বিপরীত করার বিভিন্ন পদ্ধতি চালায় (শেষ বিভাগে প্রদর্শিত আউটপুট)।
from timeit import timeit
from copy import copy
def time_str_ms(t):
return '{0:8.2f} ms'.format(t * 1000)যদি লক্ষ্যটি কেবল বিদ্যমান তালিকার আইটেমগুলির ক্রমটি বিপরীত করা হয় তবে সেগুলি লুপ না করে বা তার সাথে কাজ করার জন্য একটি অনুলিপি না পেয়ে <list>.reverse()ফাংশনটি ব্যবহার করুন । এটিকে সরাসরি কোনও তালিকার অবজেক্টে চালান এবং সমস্ত আইটেমের ক্রমটি বিপরীত হবে:
নোট করুন যে নীচেরগুলি প্রদত্ত মূল পরিবর্তনশীলটিকে বিপরীত করবে, যদিও এটি বিপরীত তালিকাটিকেও ফিরে দেয়। যেমন আপনি এই ফাংশন আউটপুট ব্যবহার করে একটি অনুলিপি তৈরি করতে পারেন। সাধারণত, আপনি এটির জন্য কোনও ফাংশন তৈরি করবেন না, তবে শেষের দিকে টাইমিং কোডটি ব্যবহার করার জন্য আমি এটি করেছি।
আমরা এই দুটি উপায়ে পারফরম্যান্স পরীক্ষা করব - প্রথমে কেবলমাত্র স্থানটি তালিকার বিপরীতে (মূল তালিকাটি পরিবর্তন করে) এবং তারপরে তালিকাটি অনুলিপি করে তারপরে এটিকে বিপরীত করব।
def rev_in_place(mylist):
mylist.reverse()
return mylist
def rev_copy_reverse(mylist):
a = copy(mylist)
a.reverse()
return aobj[::-1]অন্তর্নির্মিত সূচক টুকরা পদ্ধতি আপনাকে যে কোনও সূচী বস্তুর অংশের একটি অনুলিপি তৈরি করতে দেয়।
জেনেরিক সিনট্যাক্স হল: <object>[first_index:last_index:step]। একটি সহজ বিপরীত তালিকা, ব্যবহার তৈরি করতে slicing কাজে লাগান করার জন্য: <list>[::-1]। কোনও বিকল্প খালি রেখে দেওয়ার সময় এটি তাদের প্রথম এবং শেষ উপাদানটির ডিফল্ট হিসাবে সেট করে (ধাপের আকারটি নেতিবাচক হলে বিপরীত)।
ইনডেক্সিং একটিকে নেতিবাচক সংখ্যাগুলি ব্যবহার করতে দেয়, যা বস্তুর সূচকের শেষ থেকে পিছনের দিকে (যেমন -2 শেষ আইটেমের দ্বিতীয়) গণনা করে। যখন পদক্ষেপের আকার নেতিবাচক হয়, এটি শেষ আইটেম দিয়ে শুরু হবে এবং সেই পরিমাণ দ্বারা পিছিয়ে সূচক হবে। এর সাথে যুক্ত কিছু স্টার্ট-এন্ড যুক্তি রয়েছে যা অনুকূলিত হয়েছে।
def rev_slice(mylist):
a = mylist[::-1]
return areversed(obj)পুনরাবৃত্তি ফাংশন সহ একটি তালিকা বিপরীতএকটি reversed(indexed_object)ফাংশন আছে:
একটি কাঁচা পুনরুক্তিকারী উভয় দিয়ে পরীক্ষা করুন এবং পুনরুক্তি থেকে একটি তালিকা তৈরি করুন।
def reversed_iterator(mylist):
a = reversed(mylist)
return a
def reversed_with_list(mylist):
a = list(reversed(mylist))
return aসময়টি যেমন প্রদর্শিত হবে, তত্ক্ষণাত আপনার নিজস্ব পদ্ধতি তৈরি করা একটি খারাপ ধারণা। আপনার সত্যিকারের কাস্টম কিছু করার প্রয়োজন না হলে অন্তর্নির্মিত পদ্ধতিগুলি ব্যবহার করুন।
এটি বলেছিল, ছোট তালিকা মাপের সাথে একটি বিশাল জরিমানা নেই, তবে আপনি যখন পেনাল্টিটি স্কেল করেন তখন অসাধারণ হয়ে যায়। আমি নিশ্চিত যে নীচের আমার কোডটি অপ্টিমাইজ করা যেতে পারে তবে আমি অন্তর্নির্মিত পদ্ধতিগুলির সাথে লেগে থাকব।
def rev_manual_pos_gen(mylist):
max_index = len(mylist) - 1
return [ mylist[max_index - index] for index in range(len(mylist)) ]
def rev_manual_neg_gen(mylist):
## index is 0 to 9, but we need -1 to -10
return [ mylist[-index-1] for index in range(len(mylist)) ]
def rev_manual_index_loop(mylist):
a = []
reverse_index = len(mylist) - 1
for index in range(len(mylist)):
a.append(mylist[reverse_index - index])
return a
def rev_manual_loop(mylist):
a = []
reverse_index = len(mylist)
for index, _ in enumerate(mylist):
reverse_index -= 1
a.append(mylist[reverse_index])
return aবিপরীতে প্রতিটি পদ্ধতির সময় অনুযায়ী স্ক্রিপ্টের বাকি অংশগুলি নীচে দেওয়া হয়েছে। এটি দেখায় যে স্থানে বিপরীত হওয়া obj.reverse()এবং reversed(obj)পুনরুক্তি তৈরি করা সর্বদা দ্রুততম, স্লাইসগুলি ব্যবহার করা অনুলিপি তৈরির দ্রুততম উপায়।
এটি আপনার নিজের মতো করে করার উপায় তৈরি করার চেষ্টা না করার প্রমাণ দেয়!
loops_to_test = 100000
number_of_items = 10
list_to_reverse = list(range(number_of_items))
if number_of_items < 15:
print("a: {}".format(list_to_reverse))
print('Loops: {:,}'.format(loops_to_test))
# List of the functions we want to test with the timer, in print order
fcns = [rev_in_place, reversed_iterator, rev_slice, rev_copy_reverse,
reversed_with_list, rev_manual_pos_gen, rev_manual_neg_gen,
rev_manual_index_loop, rev_manual_loop]
max_name_string = max([ len(fcn.__name__) for fcn in fcns ])
for fcn in fcns:
a = copy(list_to_reverse) # copy to start fresh each loop
out_str = ' | out = {}'.format(fcn(a)) if number_of_items < 15 else ''
# Time in ms for the given # of loops on this fcn
time_str = time_str_ms(timeit(lambda: fcn(a), number=loops_to_test))
# Get the output string for this function
fcn_str = '{}(a):'.format(fcn.__name__)
# Add the correct string length to accommodate the maximum fcn name
format_str = '{{fx:{}s}} {{time}}{{rev}}'.format(max_name_string + 4)
print(format_str.format(fx=fcn_str, time=time_str, rev=out_str))ফলাফলগুলি দেখায় যে স্কেলিং কোনও প্রদত্ত কাজের জন্য সর্বোত্তম উপযুক্ত অন্তর্নির্মিত পদ্ধতিগুলির সাথে সবচেয়ে ভাল কাজ করে। অন্য কথায়, অবজেক্ট অ্যালিমেন্টের গণনা বাড়ার সাথে সাথে বিল্ট-ইন পদ্ধতিতে আরও উন্নত পারফরম্যান্স ফলাফল হতে শুরু করে।
আপনি একসাথে জিনিসগুলি স্ট্রিংয়ের চেয়ে আপনার যা প্রয়োজন তা সরাসরি অর্জন করে এমন সেরা অন্তর্নির্মিত পদ্ধতিটি ব্যবহার করে আরও ভাল better অর্থাত্ বিপরীত তালিকার একটি অনুলিপি প্রয়োজনে স্লাইসিং সবচেয়ে ভাল - এটি reversed()ফাংশন থেকে একটি তালিকা তৈরি করার চেয়ে দ্রুত এবং তালিকার একটি অনুলিপি তৈরি করার পরে এবং পরে একটি জায়গায় রাখার চেয়ে দ্রুত obj.reverse()। তবে যদি সেই পদ্ধতিগুলির মধ্যে আপনার যদি প্রয়োজন হয় তবে তা দ্রুত হয় তবে গতি দ্বিগুণের বেশি হয় না। এদিকে - কাস্টম, ম্যানুয়াল পদ্ধতিগুলি দীর্ঘতর আকারের অর্ডার নিতে পারে, বিশেষত খুব বড় তালিকাগুলির সাথে।
স্কেলিংয়ের জন্য, 1000 আইটেমের তালিকার সাথে, reversed(<list>)ফাংশন কলটি পুনরাবৃত্তকারীকে সেটআপ করতে 30 মিলিয়ন ডলার লাগে, স্থানে বিপরীতে কেবল ~ 55 এমএস লাগে, স্লাইস পদ্ধতিটি ব্যবহার করে সম্পূর্ণ বিপরীত তালিকার একটি অনুলিপি তৈরি করতে 210 ডলার লাগে, তবে আমি তৈরি করা দ্রুততম ম্যানুয়াল পদ্ধতিতে ~ 8400 এমএস লাগলো!
তালিকায় 2 টি আইটেম সহ:
a: [0, 1]
Loops: 100,000
rev_in_place(a): 24.70 ms | out = [1, 0]
reversed_iterator(a): 30.48 ms | out = <list_reverseiterator object at 0x0000020242580408>
rev_slice(a): 31.65 ms | out = [1, 0]
rev_copy_reverse(a): 63.42 ms | out = [1, 0]
reversed_with_list(a): 48.65 ms | out = [1, 0]
rev_manual_pos_gen(a): 98.94 ms | out = [1, 0]
rev_manual_neg_gen(a): 88.11 ms | out = [1, 0]
rev_manual_index_loop(a): 87.23 ms | out = [1, 0]
rev_manual_loop(a): 79.24 ms | out = [1, 0]তালিকার 10 টি আইটেম সহ:
rev_in_place(a): 23.39 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
reversed_iterator(a): 30.23 ms | out = <list_reverseiterator object at 0x00000290A3CB0388>
rev_slice(a): 36.01 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_copy_reverse(a): 64.67 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
reversed_with_list(a): 50.77 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_pos_gen(a): 162.83 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_neg_gen(a): 167.43 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_index_loop(a): 152.04 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_loop(a): 183.01 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]এবং তালিকার 1000 টি আইটেম সহ:
rev_in_place(a): 56.37 ms
reversed_iterator(a): 30.47 ms
rev_slice(a): 211.42 ms
rev_copy_reverse(a): 295.74 ms
reversed_with_list(a): 418.45 ms
rev_manual_pos_gen(a): 8410.01 ms
rev_manual_neg_gen(a): 11054.84 ms
rev_manual_index_loop(a): 10543.11 ms
rev_manual_loop(a): 15472.66 msসাক্ষাত্কারের জন্য অনুশীলনের জন্য কিছু পুরাতন স্কুল যুক্তি ব্যবহার করে।
সামনে থেকে পিছনে নম্বর অদলবদল করা। দুটি পয়েন্টার ব্যবহার করে
index[0] and index[last]
def reverse(array):
n = array
first = 0
last = len(array) - 1
while first < last:
holder = n[first]
n[first] = n[last]
n[last] = holder
first += 1
last -= 1
return n
input -> [-1 ,1, 2, 3, 4, 5, 6]
output -> [6, 1, 2, 3, 4, 5, -1]আপনি অ্যারে সূচকটির বিটওয়াই পরিপূরকটিও ব্যবহার করতে পারেন বিপরীতে অ্যারের মধ্য দিয়ে যেতে:
>>> array = [0, 10, 20, 40]
>>> [array[~i] for i, _ in enumerate(array)]
[40, 20, 10, 0]আপনি যাই করুন না কেন, এইভাবে করবেন না।
আর একটি সমাধান হ'ল এর জন্য numpy.flip ব্যবহার করা
import numpy as np
array = [0, 10, 20, 40]
list(np.flip(array))
[40, 20, 10, 0]কঠোরভাবে বলতে, প্রশ্ন হল কিভাবে বিপরীত একটি তালিকা ফিরতে বরং কিভাবে একটি উদাহরণ তালিকা নামের সঙ্গে একটি তালিকা বিপরীত নয় array।
নামে একটি তালিকা বিপরীত "array"ব্যবহার array.reverse()।
বর্ণিত হিসাবে অবিশ্বাস্যভাবে দরকারী স্লাইস পদ্ধতিটি নিজেই ব্যবহার করে তালিকার সংশোধন হিসাবে তালিকাটিকে সংজ্ঞায়িত করে একটি তালিকার বিপরীতে ব্যবহার করতে পারে array = array[::-1]।
array[:] = array[::-1]
অন্তর্নির্মিত ফাংশনগুলির ন্যূনতম পরিমাণ সহ, এটি ইন্টারভিউ সেটিংস ধরে নিয়ে
array = [1, 2, 3, 4, 5, 6,7, 8]
inverse = [] #create container for inverse array
length = len(array) #to iterate later, returns 8
counter = length - 1 #because the 8th element is on position 7 (as python starts from 0)
for i in range(length):
inverse.append(array[counter])
counter -= 1
print(inverse)def reverse(my_list):
L = len(my_list)
for i in range(L/2):
my_list[i], my_list[L-i - 1] = my_list[L-i-1], my_list[i]
return my_list//মেঝে বিভাগ অপারেটর সঙ্গে ভাল ।
আপনি তালিকাটিকে সর্বদা স্ট্যাকের মতো চিকিত্সা করতে পারেন কেবল তালিকার শেষ প্রান্ত থেকে স্ট্যাকের শীর্ষে উপাদানগুলি পপ করে। এইভাবে আপনি প্রথম স্ট্যাকের বৈশিষ্ট্যগুলির মধ্যে প্রথমটি গ্রহণ করেন। অবশ্যই আপনি 1 ম অ্যারে গ্রাস করছেন। আমি এই পদ্ধতিটি পছন্দ করি যাতে এটি বেশ স্বজ্ঞাত যে আপনি দেখতে পাচ্ছেন একটি তালিকা পিছনের প্রান্ত থেকে গ্রাস করা হচ্ছে যখন অন্যটি শেষ প্রান্ত থেকে তৈরি করা হচ্ছে।
>>> l = [1,2,3,4,5,6]; nl=[]
>>> while l:
nl.append(l.pop())
>>> print nl
[6, 5, 4, 3, 2, 1]list_data = [1,2,3,4,5]
l = len(list_data)
i=l+1
rev_data = []
while l>0:
j=i-l
l-=1
rev_data.append(list_data[-j])
print "After Rev:- %s" %rev_data ব্যবহার
print(reversed(list_name))জেনারেটর ব্যবহার করে অলসভাবে বিপরীত মূল্যায়ন করার একটি উপায় :
def reverse(seq):
for x in range(len(seq), -1, -1): #Iterate through a sequence starting from -1 and increasing by -1.
yield seq[x] #Yield a value to the generatorএখন এর মাধ্যমে পুনরাবৃত্তি করুন:
for x in reverse([1, 2, 3]):
print(x)আপনার যদি একটি তালিকা প্রয়োজন:
l = list(reverse([1, 2, 3]))বিপরীত তালিকা পেতে 3 টি পদ্ধতি রয়েছে:
কাটা পদ্ধতি 1: reversed_array = array[-1::-1]
কাটা পদ্ধতি 2:
reversed_array2 = array[::-1]
বিল্টিন ফাংশন ব্যবহার করে: reversed_array = array.reverse()
তৃতীয় ফাংশনটি বাস্তবে তালিকার বস্তুটিকে বিপরীত করে। এর অর্থ আদি তথ্যগুলির কোনও অনুলিপি বজায় থাকে না। আপনি যদি পুরানো সংস্করণ বজায় রাখতে না চান তবে এটি একটি ভাল পদ্ধতির। আপনি যদি মূল এবং বিপরীত সংস্করণটি চান তবে এটি সমাধান বলে মনে হচ্ছে না।