range()পাইথন দিয়ে আপনি নীচের তালিকাটি কীভাবে তৈরি করতে পারেন ?
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]উত্তর:
reversed()ফাংশন ব্যবহার :
reversed(range(10))এটি অনেক বেশি অর্থবহ।
হালনাগাদ:
আপনি যদি এটি একটি তালিকা হতে চান (যেমন বিটিকে নির্দেশিত):
list(reversed(range(10)))হালনাগাদ:
আপনি যদি rangeএকই ফলাফল অর্জন করতে ব্যবহার করতে চান তবে আপনি এর সমস্ত পরামিতি ব্যবহার করতে পারেন।range(start, stop, step)
উদাহরণস্বরূপ, একটি তালিকা তৈরি [5,4,3,2,1,0]করতে, আপনি নিম্নলিখিতটি ব্যবহার করতে পারেন:
range(5, -1, -1)এটি কম স্বজ্ঞাত হতে পারে তবে মন্তব্যগুলির হিসাবে উল্লেখ করা হয়েছে যে, এটি আরও দক্ষ এবং বিপরীত তালিকার জন্য পরিসরের সঠিক ব্যবহার।
range(10), না range(9)। এছাড়াও, আপনি যদি একটি সম্পূর্ণরূপে গঠিত তালিকা চান (টুকরো টুকরো টুকরো করার জন্য), আপনার করা উচিত list(reversed(range(10)))।
reversedসাধারণভাবে জেনারেটর গ্রহণ করে না তবে তা গ্রহণ করে range। কেন reversed(range(10000))পুরো তালিকাটির জন্য মেমরি বরাদ্দ করা দরকার? rangeএমন কোনও বস্তু ফিরে আসতে পারে __reversed__যা কার্যকর বিপরীত পুনরাবৃত্তির অনুমতি দেয় এমন পদ্ধতি প্রয়োগ করে ?
অন্তর্নির্মিত ফাংশনটি 'ব্যাপ্তি' ব্যবহার করুন। স্বাক্ষরটি হ'ল range(start, stop, step)। এটি এমন একটি ক্রম তৈরি করে যা সংখ্যার ফল দেয়, শুরু করে startএবং শেষ হয়েছে কিনা stop, বাদ দিয়ে stop।
>>> range(9,-1,-1)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> range(-2, 6, 2)
[-2, 0, 2, 4]পাইথন 3-তে, এটি একটি তালিকাবিহীন rangeঅবজেক্ট তৈরি করে, যা কেবলমাত্র পঠনযোগ্য তালিকার মতো কার্যকরভাবে কার্যকর হয় (তবে বিশেষত বৃহত্তর ব্যাপ্তির জন্য কম মেমরি ব্যবহার করে)।
help(range)অজগর শেলটি চালান তবে এটি আপনাকে আর্গুমেন্টগুলি বলবে। এগুলি শুরু করার সংখ্যা, শেষ হওয়া সংখ্যা (একচেটিয়া) এবং কী পদক্ষেপ নিতে হবে, তাই এটি 9 থেকে শুরু হয় এবং 1-বিয়োগ করা অবধি 1-এ পৌঁছায় which পরিসীমা 0 এ শেষ হয়
range(start, stop, step) - সংখ্যাটি থেকে শুরু করুন startএবং প্রতিবারের সাথে stopসরানো না হওয়া পর্যন্ত ফলন ফলাফল step।
যারা এখন পর্যন্ত সংগ্রহ করা বিকল্পগুলির "দক্ষতা" সম্পর্কে আগ্রহী তাদের জন্য ...
জেইমি RGP এর উত্তর আমার কাছে নেতৃত্বে আমার কম্পিউটার পুনরায় আরম্ভ করুন পর সময়জ্ঞান এর কিছুটা "চ্যালেঞ্জ" সমাধান জেসন আক্ষরিক আমার নিজের প্রস্তাবনা (মন্তব্য এর মাধ্যমে) করে। আপনার ডাউনটাইমটি সম্পর্কে কৌতূহলকে বাঁচানোর জন্য, আমি এখানে আমার ফলাফলগুলি উপস্থিত করছি (সবচেয়ে খারাপ):
জেসনের উত্তর ( তালিকার বোঝার শক্তিটিতে কেবলমাত্র একটি ভ্রমণ )
$ python -m timeit "[9-i for i in range(10)]"
1000000 loops, best of 3: 1.54 usec per loopমার্টিনোর উত্তর (আপনি যদি প্রসারিত টুকরো সিনট্যাক্সের সাথে পরিচিত হন তবে পাঠযোগ্য ):
$ python -m timeit "range(10)[::-1]"
1000000 loops, best of 3: 0.743 usec per loopমিশা-আরাজারের উত্তর (গ্রহণযোগ্য, খুব পাঠযোগ্য):
$ python -m timeit "reversed(range(10))"
1000000 loops, best of 3: 0.538 usec per loopবেনার এর উত্তর (খুব প্রথম, তবে সেই সময়ে খুব চিত্তাকর্ষক ):
$ python -m timeit "range(9,-1,-1)"
1000000 loops, best of 3: 0.401 usec per loopশেষ বিকল্পটি ভাল নেকম্যানেরrange(n-1,-1,-1) দ্বারা স্বরলিপিটি ব্যবহার করে মনে রাখা সহজ ।
reverseকারণ পরিসীমা পদ্ধতি বিপরীত তালিকায় ফিরে আসতে পারে।আপনার যখন এন আইটেমগুলির মাধ্যমে পুনরাবৃত্তি হয় এবং range(start, stop, step)আপনি ফিরে আসা তালিকার ক্রমটি প্রতিস্থাপন করতে চান তখন আপনাকে তৃতীয় প্যারামিটারের ব্যাপ্তি ব্যবহার করতে হবে যা সনাক্ত করে stepএবং এটিতে সেট করে -1, অন্য প্যারামিটারগুলি সেই অনুযায়ী সামঞ্জস্য করা হবে:
-1(এটা পূর্ববর্তী মান stop - 1, stopসমান ছিল 0)।n-1।বিপরীতে ক্রমের (এন) এর সমতুল্য হ'ল:
n = 10
print range(n-1,-1,-1)
#[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]reversed(range(n))
পাঠযোগ্যতা একপাশে, reversed(range(n))মনে হয় এর চেয়ে দ্রুত range(n)[::-1]।
$ python -m timeit "reversed(range(1000000000))"
1000000 loops, best of 3: 0.598 usec per loop
$ python -m timeit "range(1000000000)[::-1]"
1000000 loops, best of 3: 0.945 usec per loopকেউ যদি ভাবছিলেন :)
range(1000000000-1,-1,-1)পাশাপাশি যুক্ত করলেন না কেন ?
timeit range(1000000000-1,-1,-1)কমান্ড লাইনে চেষ্টা করবেন না , পরিবর্তে আমার ফলাফল দেখুন :-)
এই প্রশ্নের প্রয়োজনীয়তার জন্য listউত্থানের ক্রমের দশ আকারের পূর্ণসংখ্যার জন্য কল করা হবে । সুতরাং, আসুন অজগর একটি তালিকা তৈরি করুন।
# This meets the requirement.
# But it is a bit harder to wrap one's head around this. right?
>>> range(10-1, -1, -1)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
# let's find something that is a bit more self-explanatory. Sounds good?
# ----------------------------------------------------
# This returns a list in ascending order.
# Opposite of what the requirement called for.
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# This returns an iterator in descending order.
# Doesn't meet the requirement as it is not a list.
>>> reversed(range(10))
<listreverseiterator object at 0x10e14e090>
# This returns a list in descending order and meets the requirement
>>> list(reversed(range(10)))
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]-1 সত্যই পছন্দ করি এটি ঠিক এই প্যাটার্নটি এটি রাখা সহজ করে তোলে wrap one's head around this- আজ আমি শিখেছি যে যদি এটি সত্যিই দক্ষ হতেrange(n-1, -1, -1) হয় তবে বিপরীত ক্রমে কোনও সীমাটি অনুসরণ করার সময় ব্যবহার করুন ।
রেফারেন্স () বিআইএফ এর মত বিপরীত সংখ্যার মুদ্রণ আপনি করতে পারেন,
for number in range ( 10 , 0 , -1 ) :
print ( number ) আউটপুট হবে [10,9,8,7,6,5,4,3,2,1]
পরিসর () - পরিসীমা (শুরু, শেষ, বৃদ্ধি / হ্রাস) যেখানে শুরুটি অন্তর্ভুক্ত থাকে, শেষটি একচেটিয়া এবং বর্ধন যে কোনও সংখ্যা হতে পারে এবং পদক্ষেপের মতো আচরণ করে
খুব প্রায়ই জিজ্ঞাসা করা প্রশ্ন পাইথন 3 এর range(9, -1, -1)চেয়ে ভাল কিনা reversed(range(10))? যেসব লোক পুনরুক্তিকারীদের সাথে অন্যান্য ভাষায় কাজ করেছেন তাদের তাত্ক্ষণিকভাবে মনে হয় যে বিপরীত () অবশ্যই সমস্ত মান ক্যাশে করবে এবং তারপরে বিপরীত ক্রমে ফিরে আসবে। কথাটি হ'ল পাইথনের reversed()অপারেটরটি যদি কাজটি করে না তবে যদি বস্তুটি কেবল একটি পুনরাবৃত্ত হয়। বিপরীত () কাজ করার জন্য অবজেক্টটির নীচের দু'এর একটি থাকতে হবে:
len()এবং পূর্ণসংখ্যার সূচক মাধ্যমে[]__reversed__()পদ্ধতি প্রয়োগ করা হয়েছে।যদি আপনি ওপরের কোনওটিই নেই এমন বস্তুটিতে বিপরীত () ব্যবহার করার চেষ্টা করেন তবে আপনি পাবেন:
>>> [reversed((x for x in range(10)))]
TypeError: 'generator' object is not reversibleসুতরাং সংক্ষেপে, পাইথন reversed()কেবলমাত্র বস্তুর মতো অ্যারেতে বোঝানো হয় এবং তাই এতে ফরোয়ার্ড পুনরাবৃত্তির মতোই পারফরম্যান্স হওয়া উচিত।
তবে কি range()? এটা কি জেনারেটর নয়? পাইথন 3 এ এটি জেনারেটর তবে একটি শ্রেণিতে আবৃত যা উপরের উভয়টিকেই কার্যকর করে। সুতরাংrange(100000) প্রচুর স্মৃতি গ্রহণ করে না তবে এটি এখনও দক্ষ ইনডেক্সিং এবং বিপরীতকে সমর্থন করে।
সুতরাং সংক্ষেপে, আপনি reversed(range(10))পারফরম্যান্সের কোনও হিট ছাড়াই ব্যবহার করতে পারেন ।
আমি বিশ্বাস করি এটি সাহায্য করতে পারে,
range(5)[::-1]নীচে ব্যবহার:
for i in range(5)[::-1]:
print i range(9,-1,-1)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]reversed(range(10))ত্রুটি-প্রবণতা কম। কোনও অপরাধ অ্যাসিনাক্স নয়। শুধু একটি সৎ পর্যবেক্ষণ।
[:: - 1] ছাড়াই বা বিপরীত ব্যবহার করে -
def reverse(text):
result = []
for index in range(len(text)-1,-1,-1):
c = text[index]
result.append(c)
return ''.join(result)
print reverse("python!")"python!"[::-1]?
আপনার অবিচ্ছিন্নভাবে পরিসীমা ফাংশনটি ব্যবহার করার দরকার নেই, আপনি কেবল তালিকা [:: - 1] করতে পারেন যা কোনও সংযোজন না করে বিপরীত ক্রমে তালিকাটি দ্রুত ফিরিয়ে আনবে।
ধরুন আপনার একটি লিস্ট আছে এটি কল করুন = = = 1,2,3,4,5} এখন আপনি যদি তালিকাটি বিপরীতে মুদ্রণ করতে চান তবে কেবল নীচের কোডটি ব্যবহার করুন।
a.reverse
for i in a:
print(i)আমি জানি আপনি পরিসীমা ব্যবহার করতে বলেছিলেন তবে এর উত্তর ইতিমধ্যে দেওয়া আছে।
range(9,-1,-1)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]সঠিক ফর্ম হয়। আপনি যদি ব্যবহার
reversed(range(10))আপনি একটি 0 কেস পাবেন না। উদাহরণস্বরূপ, বলুন যে আপনার 10 টি কোনও যাদু নম্বর নয় এবং আপনি পরিবর্তনটি বিপরীত থেকে শুরু করার জন্য ব্যবহার করছেন vari যদি আপনার এন কেস 0 হয় তবে বিপরীত (পরিসর (0)) কার্যকর করবে না যা ভুল বলে যদি আপনার সুযোগে শূন্য সূচকে কোনও একক বস্তু থাকে।
আমি ভেবেছিলাম যে অনেকগুলি (নিজেকে হিসাবে) পরিবর্তিত ক্রমে বিদ্যমান তালিকার পরিবর্তে সাধারণ ক্ষেত্রে বেশি আগ্রহী হতে পারে , যেমন শিরোনামে বলা হয়েছে, কেবল এই জাতীয় ট্র্যাভারসালের জন্য সূচক তৈরি করার পরিবর্তে।
যদিও, সমস্ত ক্ষেত্রে সঠিক উত্তর এখনও এই ক্ষেত্রে পুরোপুরি ঠিক আছে, আমি উল্লেখ করতে চাই যে ওল্ফের উত্তরে সম্পাদিত পারফরম্যান্স তুলনাটি কেবল সূচক উত্পন্ন করার জন্য। সুতরাং আমি বিপরীত ক্রমে বিদ্যমান তালিকাটি অতিক্রমের জন্য একই জাতীয় মানদণ্ড তৈরি করেছি।
টিএল; ডিআর a[::-1] দ্রুততম।
পূর্বশর্ত:
a = list(range(10))%timeit [a[9-i] for i in range(10)]
1.27 µs ± 61.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)%timeit a[::-1]
135 ns ± 4.07 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)%timeit list(reversed(a))
374 ns ± 9.87 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)%timeit [a[i] for i in range(9, -1, -1)]
1.09 µs ± 11.1 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)যেমন আপনি দেখতে পাচ্ছেন, এক্ষেত্রে সুস্পষ্টভাবে সূচকগুলি তৈরি করার দরকার নেই, তাই দ্রুততম পদ্ধতিটি হ'ল অতিরিক্ত অতিরিক্ত ক্রিয়া করে।
এনবি: আমি জপিটারল্যাবে পরীক্ষা করেছি যার হাতে "ম্যাজিক কমান্ড" রয়েছে %timeit। এটি timeit.timeitহুডের নীচে মান ব্যবহার করে। পাইথন ৩.7.৩ এর জন্য পরীক্ষিত