একটি 'ফর' লুপে শেষ উপাদানটি সনাক্ত করার অজগর উপায় কী?

Question

লুপের জন্য শেষ উপাদানটির জন্য একটি বিশেষ চিকিত্সা করার জন্য আমি সর্বোত্তম উপায় (আরও কমপ্যাক্ট এবং "পাইথোনিক" উপায়) জানতে চাই। কোডের একটি টুকরা রয়েছে যা কেবলমাত্র উপাদানগুলির মধ্যে ডাকা উচিত , সর্বশেষে চাপা দেওয়া।

এখানে আমি বর্তমানে এটি কীভাবে করছি:

for i, data in enumerate(data_list):
    code_that_is_done_for_every_element
    if i != len(data_list) - 1:
        code_that_is_done_between_elements

এর চেয়ে ভাল উপায় আর কি আছে?

দ্রষ্টব্য: আমি হ্যাক ব্যবহার করে যেমন এটি তৈরি করতে চাই না reduce।;)

Comments

সে প্রথম সম্পর্কে কি? এটাও দমন করা উচিত?

— আদম মতান

আপনি আমাদের বলতে পারেন যে এটি উপাদানগুলির মধ্যে কী করা হচ্ছে?

— সাইলেন্টগোস্ট

আমি জেনেরিক কেসের জন্য উত্তর পেতে চাই, তবে একটি কংক্রিটের ক্ষেত্রে যেখানে আমার এটির দরকার তা হ'ল স্ট্রিমে কিছু লেখার সাথে তাদের মধ্যে বিভাজকদের মত স্ট্রিম.উরাইট (',' .জাইন (নাম_লিস্ট)), তবে স্ট্রিংগুলিকে

— বিনষ্ট

সম্পর্কিত: stackoverflow.com/questions/323750/...

— codeape

এই উত্তরের প্রথম তিনটি লাইন সত্যই আমাকে সহায়তা করেছিল, একই রকম চ্যালেঞ্জ ছিল।

— এলাচি

Answer 1

বেশিরভাগ সময় প্রথম পুনরাবৃত্তিকে শেষের পরিবর্তে বিশেষ ক্ষেত্রে করা সহজ (এবং সস্তা) হয় :

first = True
for data in data_list:
    if first:
        first = False
    else:
        between_items()

    item()

এটি যে কোনও পুনরাবৃত্তিযোগ্য এমনকি তাদের জন্যও কাজ করবে len():

file = open('/path/to/file')
for line in file:
    process_line(line)

    # No way of telling if this is the last line!

এগুলি ছাড়াও, আমি মনে করি না যে এটি করার চেষ্টা করছেন তার উপর নির্ভর করে একটি সাধারণতর উত্কৃষ্ট সমাধান রয়েছে। উদাহরণস্বরূপ, আপনি যদি একটি তালিকা থেকে স্ট্রিং তৈরি str.join()করে থাকেন তবে for"বিশেষ ক্ষেত্রে" একটি লুপ ব্যবহার না করে স্বাভাবিকভাবে ব্যবহার করা ভাল ।

---

একই নীতি ব্যবহার করে তবে আরও কমপ্যাক্ট:

for i, line in enumerate(data_list):
    if i > 0:
        between_items()
    item()

দেখে মনে হচ্ছে, তাই না? :)

---

@ আফকো এবং অন্যদের জন্য যাঁদের সত্যিকারের ব্যতীত পুনরাবৃত্তের বর্তমান মানটি len()সর্বশেষ হয় কিনা তা খুঁজে বের করতে আপনার পক্ষে সামনের দিকে তাকাতে হবে:

def lookahead(iterable):
    """Pass through all values from the given iterable, augmented by the
    information if there are more values to come after the current one
    (True), or if it is the last value (False).
    """
    # Get an iterator and pull the first value.
    it = iter(iterable)
    last = next(it)
    # Run the iterator to exhaustion (starting from the second value).
    for val in it:
        # Report the *previous* value (more to come).
        yield last, True
        last = val
    # Report the last value.
    yield last, False

তারপরে আপনি এটি ব্যবহার করতে পারেন:

>>> for i, has_more in lookahead(range(3)):
...     print(i, has_more)
0 True
1 True
2 False

Comments

সত্য, এই উপায়টি আমার চেয়ে ভাল বলে মনে হচ্ছে, কমপক্ষে এটি গণনা এবং লেন ব্যবহার করার দরকার নেই।

— e.tadeu

হ্যাঁ, তবে এটিতে আরও একটি যুক্ত হয় ifযা লুপটি দুটি লুপে বিভক্ত হলে এড়ানো যায় could তবে, কেবলমাত্র বিশাল ডেটা তালিকার পুনরাবৃত্তি করার সময় এটি প্রাসঙ্গিক।

— আদম মতান

দুটি লুপে বিভক্ত হওয়ার সমস্যা হ'ল এটি ডিআরওয়াই লঙ্ঘন করে বা এটি আপনাকে পদ্ধতিগুলি সংজ্ঞায়িত করতে বাধ্য করে।

— ই.টাদিউ

আমি আপনার শেষ উদাহরণটি বোঝার চেষ্টা করি (যা আমার কোডে নির্বিঘ্নে কাজ করে) তবে আমি বুঝতে পারি না এটি কীভাবে কাজ করে (পিছনের ধারণাটি)

— অলিভিয়ার পন্স

@ অলিভিয়ারপোনস আপনাকে পাইথনের পুনরাবৃত্তকারী প্রোটোকলটি বোঝার দরকার: আমি কোনও সামগ্রীর জন্য একটি পুনরুদ্ধারক পাই এবং এর সাথে প্রথম মানটি পুনরুদ্ধার করি next()। তারপরে আমি কাজে লাগিয়েছি যে কোনও পুনরুক্তিকারী নিজে থেকেই পুনরাবৃত্তিযোগ্য, তাই আমি এটি forক্লান্ত হওয়া অবধি লুপটিতে ব্যবহার করতে পারি , দ্বিতীয় থেকে শেষ মান পর্যন্ত পুনরাবৃত্তি। এটি চলাকালীন আমি স্থানীয়ভাবে পুনরুক্তিকারীর কাছ থেকে স্থানীয়ভাবে এবং yieldতার পরিবর্তে সর্বশেষ মানটি রেখেছি । এইভাবে আমি জানি আরও একটি মান আসবে। লুপের পরে, আমি প্রতিটি মানটি জানিয়েছি তবে শেষটি।

— ফার্ডিনান্দ বায়ার

Answer 2

যদিও এই প্রশ্নটি বেশ পুরানো, আমি গুগলের মাধ্যমে এখানে এসেছি এবং আমি একটি খুব সহজ উপায় খুঁজে পেয়েছি: তালিকাগুলির তালিকা। ধরা যাক আপনি সমস্ত তালিকা এন্ট্রিগুলির মধ্যে একটি '&' রাখতে চান।

s = ""
l = [1, 2, 3]
for i in l[:-1]:
    s = s + str(i) + ' & '
s = s + str(l[-1])

এটি '1 & 2 & 3' দেয়।

Comments

`" & ".Join ([Str (x) এর জন্য x- ঠ-এ]): আপনি শুধু ফাংশন যোগদানের reimplemented থাকেন

— ব্রায়ান Oakley,

স্ট্রিং কনটেনটেশন কিছুটা অক্ষম। যদি len(l)=1000000এই উদাহরণে, প্রোগ্রামটি কিছু সময়ের জন্য চলবে। appendআফাইক সুপারিশ করা হয়। l=[1,2,3]; l.append(4);

— plhn

Answer 3

'কোড এর মধ্যে' শিরোনাম-লেজ প্যাটার্নের একটি উদাহরণ ।

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

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

def item_processing( item ):
    # *the common processing*

head_tail_iter = iter( someSequence )
head = head_tail_iter.next()
item_processing( head )
for item in head_tail_iter:
    # *the between processing*
    item_processing( item )

এটি আরও নির্ভরযোগ্য কারণ এটি প্রমাণ করা কিছুটা সহজ, এটি কোনও অতিরিক্ত ডেটা কাঠামো তৈরি করে না (অর্থাত্ তালিকার একটি অনুলিপি) এবং যদি কোনও শর্ত ছাড়া সবসময় মিথ্যা হয় তবে যদি একটি শর্ত কার্যকর করতে না হয় তবে প্রচুর অপচয় হবে execution

Comments

ফাংশন কলগুলি ধীরে ধীরে ধীরে ধীরে ifবিবৃতি হয় যাতে "নষ্ট হওয়া কার্যকর" আর্গুমেন্টটি ধরে না।

— ফার্ডিনান্দ বায়ার

আমি নিশ্চিত না যে ফাংশন কল এবং যদি-স্টেটমেন্টের কোনও কিছুর সাথে গতির পার্থক্য কী। বিন্দু এই সূত্র কোন যদি-বিবৃতি যে সবসময় মিথ্যা রয়েছে (একবার ব্যতীত।)

— S.Lott

আমি আপনার বক্তব্যটির ব্যাখ্যা দিয়েছিলাম "... এবং যদি একটি শর্ত ছাড়া সর্বদা মিথ্যা হয় তবে এটির প্রচুর অপচয় হ'ল প্রয়োজন হয় না" হিসাবে "... এবং এটি বেশ কয়েক'টি সংরক্ষণ করে" তত দ্রুত if। স্পষ্টতই আপনি কেবল "কোড পরিষ্কারের" কথা উল্লেখ করছেন?

— ফার্ডিনান্ড বায়ার

ifপাইথন সম্প্রদায়ের দ্বারা ক্লিয়ার হিসাবে বিবেচিত কোনও বিবৃতি ব্যবহারের পরিবর্তে কোনও ফাংশন সংজ্ঞায়িত করা হচ্ছে ?

— মার্কাস ভন ব্রডি

Answer 4

আপনি যদি কেবলমাত্র সর্বশেষ উপাদানটি পরিবর্তন data_listকরতে চান তবে আপনি স্বরলিপিটি ব্যবহার করতে পারেন:

L[-1]

তবে দেখে মনে হচ্ছে আপনি এর চেয়ে আরও বেশি কিছু করছেন doing আপনার উপায় নিয়ে আসলেই কোনও ভুল নেই। আমি এমনকি তাদের টেম্পলেট ট্যাগগুলির জন্য কিছু জ্যাঙ্গো কোডে তাত্ক্ষণিকভাবে নজর রেখেছি এবং তারা আপনি যা করছেন তা মূলত তারা করে।

Comments

আমি এটিকে সংশোধন করছি না, আমি এটি কিছু করার জন্য ব্যবহার করছি

— e.tadeu

@ e.tadeu আপনি এটি সংশোধন করছেন কিনা তা বিবেচ্য নয়। আপনার যদি বিবৃতিটির প্রতি এতে পরিবর্তন হয়: if data != datalist[-1]:এবং সমস্ত কিছু একইরকম রাখা আমার মতে এটি কোড করার সর্বোত্তম উপায়।

— স্পেসটাইপার

@ স্পেসিটাইপার এটি শেষ হবে যখন শেষ মানটি অনন্য।

— অর্ক-কুন

Answer 5

আইটেমগুলি অনন্য হলে:

for x in list:
    #code
    if x == list[-1]:
        #code

অন্যান্য অপশন:

pos = -1
for x in list:
    pos += 1
    #code
    if pos == len(list) - 1:
        #code


for x in list:
    #code
#code - e.g. print x


if len(list) > 0:
    for x in list[:-1]
        #code
    for x in list[-1]:
        #code

Answer 6

এটি আন্টস আসমার পদ্ধতির অনুরূপ তবে এটির্টোল মডিউলটি ব্যবহার না করেই। এটি একটি পিছিয়ে থাকা পুনরুক্তিও যা পুনরাবৃত্ত প্রবাহের একক উপাদানকে এগিয়ে দেখায়:

def last_iter(it):
    # Ensure it's an iterator and get the first field
    it = iter(it)
    prev = next(it)
    for item in it:
        # Lag by one item so I know I'm not at the end
        yield 0, prev
        prev = item
    # Last item
    yield 1, prev

def test(data):
    result = list(last_iter(data))
    if not result:
        return
    if len(result) > 1:
        assert set(x[0] for x in result[:-1]) == set([0]), result
    assert result[-1][0] == 1

test([])
test([1])
test([1, 2])
test(range(5))
test(xrange(4))

for is_last, item in last_iter("Hi!"):
    print is_last, item

Answer 7

আপনি ইনপুট ডেটার উপরে একটি স্লাইডিং উইন্ডো ব্যবহার করতে পারেন পরবর্তী মানটি দেখুন এবং শেষ মানটি সনাক্ত করতে একটি সেন্ডিনেল ব্যবহার করতে পারেন। এটি কোনও পুনরাবৃত্তির উপরে কাজ করে, সুতরাং আপনার দৈর্ঘ্য আগে জানার দরকার নেই। জুটিওয়ালা প্রয়োগটি হ'ল ইটারল্টুল রেসিপি থেকে ।

from itertools import tee, izip, chain

def pairwise(seq):
    a,b = tee(seq)
    next(b, None)
    return izip(a,b)

def annotated_last(seq):
    """Returns an iterable of pairs of input item and a boolean that show if
    the current item is the last item in the sequence."""
    MISSING = object()
    for current_item, next_item in pairwise(chain(seq, [MISSING])):
        yield current_item, next_item is MISSING:

for item, is_last_item in annotated_last(data_list):
    if is_last_item:
        # current item is the last item

Answer 8

সর্বশেষে তবে শেষ উপাদানটির পুনরাবৃত্তি করার এবং লুপের বাইরে শেষটির চিকিত্সার কোনও সম্ভাবনা নেই? সর্বোপরি, আপনি যে সমস্ত উপাদানগুলি লুপ করেন তার অনুরূপ কিছু করার জন্য একটি লুপ তৈরি করা হয়; যদি কোনও উপাদানটির জন্য বিশেষ কিছু প্রয়োজন হয় তবে এটি লুপে থাকা উচিত নয়।

(এই প্রশ্নটিও দেখুন: একটি-লুপ-প্রাপ্য-একটি-পৃথক-চিকিত্সা-সর্বশেষ উপাদান করে )

সম্পাদনা: যেহেতু প্রশ্ন "মধ্যবর্তী" সম্পর্কে আরও বেশি তাই প্রথম উপাদানটি বিশেষ যেটির কোনও পূর্বসূরি নেই, বা শেষ উপাদানটি বিশেষ যে এর কোনও উত্তরসূরি নেই।

Comments

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

— ই.তোদিউ

সেক্ষেত্রে প্রথমটি পূর্বসূরি ব্যতীত একমাত্র। এটিকে আলাদা করে রাখুন এবং বাকী তালিকাটির সাধারণ কোডটি লুপ করুন।

— xtofl

Answer 9

আমি @ ইথান-টি এর পদ্ধতিকে পছন্দ করি তবে while Trueআমার দৃষ্টিকোণ থেকে এটি বিপজ্জনক।

data_list = [1, 2, 3, 2, 1]  # sample data
L = list(data_list)  # destroy L instead of data_list
while L:
    e = L.pop(0)
    if L:
        print(f'process element {e}')
    else:
        print(f'process last element {e}')
del L

এখানে, data_listযাতে শেষ উপাদানটি তালিকার প্রথমটির সাথে মান অনুসারে সমান হয়। এল এর সাথে এক্সচেঞ্জ হতে পারে data_listতবে এই ক্ষেত্রে এটি লুপের পরে খালি ফলাফল করে। while Trueপ্রসেসিংয়ের আগে তালিকাটি খালি নয় বা চেকের প্রয়োজন নেই (চূড়ান্তভাবে!) যদি আপনি পরীক্ষা করে থাকেন তবে এটি ব্যবহার করাও সম্ভব।

data_list = [1, 2, 3, 2, 1]
if data_list:
    while True:
        e = data_list.pop(0)
        if data_list:
            print(f'process element {e}')
        else:
            print(f'process last element {e}')
            break
else:
    print('list is empty')

ভাল অংশ এটি দ্রুত হয়। খারাপ - এটি ধ্বংসাত্মক ( data_listখালি হয়ে যায়)।

সর্বাধিক স্বজ্ঞাত সমাধান:

data_list = [1, 2, 3, 2, 1]  # sample data
for i, e in enumerate(data_list):
    if i != len(data_list) - 1:
        print(f'process element {e}')
    else:
        print(f'process last element {e}')

ওহ হ্যাঁ, আপনি ইতিমধ্যে এটি প্রস্তাব করেছেন!

Answer 10

আপনার পদ্ধতিতে কোনও সমস্যা নেই, যদি না আপনার 100,000 লুপ থাকে এবং 100,000 "যদি" বিবৃতি সংরক্ষণ করতে চান। সেক্ষেত্রে আপনি সেই পথে যেতে পারেন:

iterable = [1,2,3] # Your date
iterator = iter(iterable) # get the data iterator

try :   # wrap all in a try / except
    while 1 : 
        item = iterator.next() 
        print item # put the "for loop" code here
except StopIteration, e : # make the process on the last element here
    print item

ফলাফল:

1
2
3
3

তবে সত্যিই, আপনার ক্ষেত্রে আমি মনে করি এটি অত্যধিক দক্ষতাযুক্ত।

যাই হোক না কেন, আপনি সম্ভবত কাটা ভাগ্যবান হতে হবে:

for item in iterable[:-1] :
    print item
print "last :", iterable[-1]

#outputs
1
2
last : 3

বা শুধু :

for item in iterable :
    print item
print iterable[-1]

#outputs
1
2
3
last : 3

শেষ পর্যন্ত, আপনার স্টাফগুলি করার একটি KISS উপায় এবং এটি কোনও ছাড়া পুনরাবৃত্তিযোগ্যগুলি সহ কাজ করবে __len__:

item = ''
for item in iterable :
    print item
print item

Ouputs:

1
2
3
3

যদি মনে হয় আমি সেভাবে এটি করব, তবে আমার কাছে সহজ বলে মনে হচ্ছে।

Comments

তবে মনে রাখবেন যে পুনরাবৃত্তযোগ্য [-1] সমস্ত পুনরাবৃত্তিতে (যেমন জেনারেটরের লেন নেই ) তে কাজ করবে না

— e.tadeu ২

লুটের পরে যদি আপনি যা চান তা হ'ল শেষ আইটেমটি অ্যাক্সেস করা, কেবল itemএটি ব্যবহার করে পুনরায় গণনার পরিবর্তে ব্যবহার করুন list[-1]। তবে তবুও: আমি মনে করি না যে ওপি এটিই চেয়েছিল, তাইনা?

— ফার্ডিনান্দ বায়ার

উত্তর: iterable.__iter__() - দয়া করে __সরাসরি ফাংশনগুলিতে কল করবেন না । হওয়া উচিত iter(iterable)।

— পলমিসজি

Answer 11

কাটা এবং isশেষ উপাদানটি পরীক্ষা করতে ব্যবহার করুন:

for data in data_list:
    <code_that_is_done_for_every_element>
    if not data is data_list[-1]:
        <code_that_is_done_between_elements>

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

Answer 12

আপনি যদি তালিকার মধ্য দিয়ে যাচ্ছেন তবে আমার জন্য এটিও কাজ করেছে:

for j in range(0, len(Array)):
    if len(Array) - j > 1:
        notLast()

Answer 13

গুগল আমাকে এই পুরানো প্রশ্নে নিয়ে এসেছিল এবং আমি মনে করি যে আমি এই সমস্যায় একটি ভিন্ন পদ্ধতির যোগ করতে পারি।

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

while True:
    element = element_list.pop(0)
    do_this_for_all_elements()
    if not element:
        do_this_only_for_last_element()
        break
    do_this_for_all_elements_but_last()

আপনি যদি লিন (এলিমেন্ট_লিস্ট) করার সময়ও ব্যবহার করতে পারেন তবে শেষ উপাদানটির সাথে আপনার কিছু করার প্রয়োজন নেই। আমি এই সমাধানটিকে আরও মার্জিত বলে মনে করি তারপরে () এর সাথে ডিল করে।

Answer 14

আমার জন্য একটি তালিকা শেষে একটি বিশেষ কেস পরিচালনা করার সবচেয়ে সহজ এবং অজগর উপায়:

for data in data_list[:-1]:
    handle_element(data)
handle_special_element(data_list[-1])

অবশ্যই এটি প্রথম উপাদানটিকে একটি বিশেষ উপায়ে চিকিত্সা করতে ব্যবহার করা যেতে পারে।

Answer 15

গণনা করার পরিবর্তে, আপনি গণনাও করতে পারেন:

  nrToProcess = len(list)
  for s in list:
    s.doStuff()
    nrToProcess -= 1
    if nrToProcess==0:  # this is the last one
      s.doSpecialStuff()

Answer 16

লুপের পরে অবধি শেষ আইটেমটির বিশেষ হ্যান্ডলিংটি বিলম্ব করুন।

>>> for i in (1, 2, 3):
...     pass
...
>>> i
3

Answer 17

একাধিক উপায় হতে পারে। কাটা দ্রুত হবে। .Index () পদ্ধতি ব্যবহার করে এমন আরও একটি যুক্ত করা:

>>> l1 = [1,5,2,3,5,1,7,43]                                                 
>>> [i for i in l1 if l1.index(i)+1==len(l1)]                               
[43]

Answer 18

একটি পুনরুক্তিকারী হিসাবে ইনপুট ধরে নিচ্ছি, এটির টিউলগুলি থেকে টি এবং আইজিপ ব্যবহারের একটি উপায় এখানে রয়েছে:

from itertools import tee, izip
items, between = tee(input_iterator, 2)  # Input must be an iterator.
first = items.next()
do_to_every_item(first)  # All "do to every" operations done to first item go here.
for i, b in izip(items, between):
    do_between_items(b)  # All "between" operations go here.
    do_to_every_item(i)  # All "do to every" operations go here.

ডেমো:

>>> def do_every(x): print "E", x
...
>>> def do_between(x): print "B", x
...
>>> test_input = iter(range(5))
>>>
>>> from itertools import tee, izip
>>>
>>> items, between = tee(test_input, 2)
>>> first = items.next()
>>> do_every(first)
E 0
>>> for i,b in izip(items, between):
...     do_between(b)
...     do_every(i)
...
B 0
E 1
B 1
E 2
B 2
E 3
B 3
E 4
>>>

Answer 19

আমার মনে আসা সবচেয়ে সহজ সমাধানটি হ'ল:

for item in data_list:
    try:
        print(new)
    except NameError: pass
    new = item
print('The last item: ' + str(new))

সুতরাং আমরা প্রসেসিংয়ের এক পুনরাবৃত্তিটি বিলম্ব করে সর্বদা একটি আইটেমের সন্ধান করি। প্রথম পুনরাবৃত্তির সময় কিছু করা এড়াতে আমি কেবল ত্রুটিটি ধরা করি catch

অবশ্যই NameErrorযখন আপনি চান তখন উত্থাপিত হওয়ার জন্য আপনাকে কিছুটা ভাবতে হবে।

St কাউন্টারট্রাক্টও রাখুন

try:
    new
except NameError: pass
else:
    # continue here if no error was raised

এটি নির্ভর করে যে নতুন নামটি আগে সংজ্ঞায়িত হয়নি। আপনি যদি ভৌতিক হয়ে থাকেন তবে আপনি নিশ্চিত করতে পারেন যে newএটি ব্যবহার করে বিদ্যমান নেই:

try:
    del new
except NameError:
    pass

বিকল্পভাবে আপনি অবশ্যই একটি if স্টেটমেন্ট ( if notfirst: print(new) else: notfirst = True) ব্যবহার করতে পারেন । তবে যতদূর জানি ওভারহেডটি বড়।

---

Using `timeit` yields:

    ...: try: new = 'test' 
    ...: except NameError: pass
    ...: 
100000000 loops, best of 3: 16.2 ns per loop

সুতরাং আমি আশা করি যে ওভারহেডটি অনিচ্ছাকৃত হবে।

Answer 20

আইটেমগুলি একবার গণনা করুন এবং অবশিষ্ট আইটেমের সংখ্যাটি বজায় রাখুন:

remaining = len(data_list)
for data in data_list:
    code_that_is_done_for_every_element

    remaining -= 1
    if remaining:
        code_that_is_done_between_elements

এইভাবে আপনি কেবলমাত্র তালিকাটির দৈর্ঘ্য একবারে মূল্যায়ন করবেন। এই পৃষ্ঠার অনেকগুলি সমাধান দৈর্ঘ্যটি আগে থেকে অনুপলব্ধ বলে মনে হয়, তবে এটি আপনার প্রশ্নের অংশ নয়। আপনার দৈর্ঘ্য থাকলে এটি ব্যবহার করুন।

Answer 21

একটি সহজ সমাধান যা মনে আসে তা হ'ল:

for i in MyList:
    # Check if 'i' is the last element in the list
    if i == MyList[-1]:
        # Do something different for the last
    else:
        # Do something for all other elements

কাউন্টার ব্যবহার করে একটি দ্বিতীয় সমান সহজ সমাধান অর্জন করা যেতে পারে:

# Count the no. of elements in the list
ListLength = len(MyList)
# Initialize a counter
count = 0

for i in MyList:
    # increment counter
    count += 1
    # Check if 'i' is the last element in the list
    # by using the counter
    if count == ListLength:
        # Do something different for the last
    else:
        # Do something for all other elements