বিকল্প ফ্যাশনে দুটি তালিকাকে একত্রিত করার পাইথোনিক উপায়?

Question

আমার দুটি তালিকাগুলি রয়েছে যার মধ্যে প্রথমটির মধ্যে দ্বিতীয়টির চেয়ে ঠিক আরও একটি আইটেম থাকার গ্যারান্টিযুক্ত । আমি একটি নতুন তালিকা তৈরির সর্বাধিক পাইথোনিক উপায়টি জানতে চাই যার সম-সূচক মানগুলি প্রথম তালিকা থেকে আসে এবং যার বিজোড়-সূচক মানগুলি দ্বিতীয় তালিকার থেকে আসে।

# example inputs
list1 = ['f', 'o', 'o']
list2 = ['hello', 'world']

# desired output
['f', 'hello', 'o', 'world', 'o']

এটি কাজ করে তবে সুন্দর নয়:

list3 = []
while True:
    try:
        list3.append(list1.pop(0))
        list3.append(list2.pop(0))
    except IndexError:
        break

আর কীভাবে এটি অর্জন করা যায়? সর্বাধিক পাইথোনিক পদ্ধতি কী?

Comments

পাইথনে

— ফেলিক্স ক্লিং

নকল নয়! উপরের লিঙ্কযুক্ত নিবন্ধে গৃহীত উত্তর টিউপসগুলির একটি তালিকা তৈরি করে, একটি একক, মার্জড তালিকা নয়।

— পল সাসিক

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

— ফেলিক্স ক্লিং

@ ফেলিক্স: আমি শ্রদ্ধার সাথে একমত নই। এটি সত্য, প্রশ্নগুলি একই পাড়ায় তবে সত্যিকারে সদৃশ নয়। অস্পষ্ট প্রমাণ হিসাবে এখানে সম্ভাব্য উত্তরগুলি একবার দেখুন এবং অন্যান্য প্রশ্নের সাথে তুলনা করুন।

— পল স্যাসিক

: এই পরীক্ষা করে দেখুন stackoverflow.com/questions/7529376/...

— wordsforthewise

Answer 1

কাটা দিয়ে এটি করার একটি উপায় এখানে:

>>> list1 = ['f', 'o', 'o']
>>> list2 = ['hello', 'world']
>>> result = [None]*(len(list1)+len(list2))
>>> result[::2] = list1
>>> result[1::2] = list2
>>> result
['f', 'hello', 'o', 'world', 'o']

Comments

ধন্যবাদ, ডানকান আমি বুঝতে পারি নি টুকরো টুকরো করার সময় কোনও পদক্ষেপ নির্দিষ্ট করা সম্ভব। আমি এই পদ্ধতির সম্পর্কে যা পছন্দ করি তা হ'ল প্রাকৃতিকভাবে এটি পড়ে। 1. সঠিক দৈর্ঘ্যের একটি তালিকা তৈরি করুন। 2. তালিকা 1 এর বিষয়বস্তু সহ সম সূচকগুলি পপুলেট করুন। ৩. তালিকার 2 টি বিষয়বস্তুর সাথে বিজোড় সূচকগুলি তৈরি করুন। তালিকাগুলি বিভিন্ন দৈর্ঘ্যের হ'ল এই ক্ষেত্রে কোনও সমস্যা নয়!

— ডেভিডচেমার্স

আমি মনে করি এটি তখনই কার্যকর হয় যখন লেন (list1) - লেন (list2) 0 বা 1 হয়

— xan

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

— ডানকান

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

— ডেভিডচেমার্স

আপনি (2 * লেন (তালিকা 1) -1) এর পরিবর্তে (লেন (তালিকা 1) + লেন (তালিকা 2)) ব্যবহার করতে পারেন, আমি [:: 2] এর পরিবর্তে [0 :: 2] পছন্দ করি।

— লর্ড ব্রিটিশ

Answer 2

itertoolsডকুমেন্টেশনে এটির জন্য একটি রেসিপি রয়েছে :

from itertools import cycle, islice

def roundrobin(*iterables):
    "roundrobin('ABC', 'D', 'EF') --> A D E B F C"
    # Recipe credited to George Sakkis
    pending = len(iterables)
    nexts = cycle(iter(it).next for it in iterables)
    while pending:
        try:
            for next in nexts:
                yield next()
        except StopIteration:
            pending -= 1
            nexts = cycle(islice(nexts, pending))

সম্পাদনা:

পাইথনের সংস্করণ 3 এর চেয়েও বড়:

from itertools import cycle, islice

def roundrobin(*iterables):
    "roundrobin('ABC', 'D', 'EF') --> A D E B F C"
    # Recipe credited to George Sakkis
    pending = len(iterables)
    nexts = cycle(iter(it).__next__ for it in iterables)
    while pending:
        try:
            for next in nexts:
                yield next()
        except StopIteration:
            pending -= 1
            nexts = cycle(islice(nexts, pending))

Comments

এটির চেয়ে প্রয়োজনটিকে আরও জটিল মনে করি complicated নীচে আরও ভাল বিকল্প ব্যবহার করা আছে zip_longest।

— ডাবসলো

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

— ডেভিড জেড

fyi আপনার itertools ডকুমেন্টেশনে রেসিপিটি ব্যবহার করা উচিত কারণ .next()আর কাজ করে না।

— জন ডাব্লু

@ জোহনউ একটি ব্যবহার করতে হবে __next__। এটি ডকুমেন্টেশনে লিখিত হয়নি তাই উত্তরে আমি সম্পাদনার প্রস্তাব দিয়েছি।

— মেরিন গ্যালানটিন

@ মেরিন আমি বরং এর আগে আপনি বিদ্যমান কোডের নমুনাটি বদলেছিলেন তবে আমি নিজেই এটি ঠিক করতে পারি। অবদানের জন্য ধন্যবাদ!

— ডেভিড জেড

Answer 3

এটি আপনার যা করা উচিত তা করা উচিত:

>>> iters = [iter(list1), iter(list2)]
>>> print list(it.next() for it in itertools.cycle(iters))
['f', 'hello', 'o', 'world', 'o']

Comments

আমি আপনার প্রাথমিক উত্তরটি সত্যই পছন্দ করেছি। যদিও এটি পুরোপুরি প্রশ্নের সমাধান করে না, এটি একই দৈর্ঘ্যের দুটি তালিকার একত্রে মার্জিত উপায়। আমি আপনার বর্তমান উত্তরে দৈর্ঘ্য ক্যাভিয়েট সহ এটি ধরে রাখার পরামর্শ দিচ্ছি।

— পল স্যাসিক

যদি তালিকা 1 এর পরিবর্তে ['f', 'o', 'o', 'd'] হয়, তবে এর চূড়ান্ত আইটেম ('d') ফলাফলের তালিকায় উপস্থিত হবে না (যা প্রশ্নের সুনির্দিষ্ট বিবরণ দিয়ে সম্পূর্ণ সূক্ষ্ম)। এটি একটি মার্জিত সমাধান!

— ডেভিডচেমার্স

@ মারক হ্যাঁ (আমি এটি উত্সাহিত করেছি), কেবলমাত্র পার্থক্যগুলি নির্দেশ করে (এবং অন্যান্য লোকেরা যদি অন্যরকম আচরণ চান তবে সীমাবদ্ধতা)

— কোব্বল

বর্ণিত সমস্যা সমাধানের জন্য +1, এবং এটি খুব সহজভাবে করার জন্য :-) আমি আবিষ্কার করেছি এরকম কিছু সম্ভব হবে। সত্যই আমি মনে করি যে roundrobinএই পরিস্থিতিটির জন্য ক্রিয়াকলাপটি একরকম ওভারকিল।

— ডেভিড জেড

যে কোনও আকারের তালিকাগুলির সাথে কাজ করতে আপনি কেবল পুনরাবৃত্তির বাকী বাক্যে যা রেখেছেন তাতে ফলাফল যুক্ত করতে পারেন:list(itertools.chain(map(next, itertools.cycle(iters)), *iters))

— পান্ডা-34

Answer 4

import itertools
print [x for x in itertools.chain.from_iterable(itertools.izip_longest(list1,list2)) if x]

আমি মনে করি এটি করার এটি সবচেয়ে সার্থক উপায়।

Comments

কেন এটি গৃহীত উত্তর নয়? এটি সংক্ষিপ্ততম এবং সর্বাধিক পাইথোনিক এবং বিভিন্ন তালিকার দৈর্ঘ্যের সাথে কাজ করে!

— জায়রো ভাদিলো

পদ্ধতি নাম izip_longest না zip_longest হয়

— Jairo Vadillo

এটির সাথে সমস্যাটি হ'ল জিপ_লজনেস্টের ডিফল্ট ফিলিন মানটি লিখিত তালিকাতে None* * বলে মনে করা উচিত ওভাররাইট করতে পারে। এটি ঠিক করার জন্য আমি একটি

— টুইটযুক্ত

দ্রষ্টব্য: তালিকায় মান সহ উপাদানগুলি Falseবা এমন কিছু রয়েছে যা কেবলমাত্র - এক্সপ্রেশন দ্বারা মূল্যায়ন করা হবে যেমন উদাহরণস্বরূপ একটি বা খালি তালিকা। এই হতে পারে (আংশিকভাবে) অনুসরণ করে এড়িয়ে যাওয়া: । অবশ্যই, তালিকায় যদি এমন উপাদান থাকে যা সংরক্ষণ করা দরকার তবে এটি এখনও কাজ করবে না । এই ক্ষেত্রে, আপনার যুক্তিটি পরিবর্তন করা দরকার , যেমন ডাবস্লো ইতিমধ্যে পরামর্শ দিয়েছে। Falseif0[x for x in itertools.chain.from_iterable(itertools.zip_longest(list1, list2)) if x is not None]Nonefillvaluezip_longest

— der_herr_g

Noneসমস্যাটি মনে হচ্ছে কমপক্ষে পাইথন ৩.7..6 থেকে (পুরানো সংস্করণগুলির জন্য আমি জানি না) since যদি alt_chainসংজ্ঞায়িত করা হয় def alt_chain(*iters, fillvalue=None): return chain.from_iterable(zip_longest(*iters, fillvalue=fillvalue))তবে list(alt_chain([0, False, 1, set(), 3, 4], [0, None, 1, {}], fillvalue=99))সঠিকভাবে প্রত্যাবর্তন হয় [0, 0, False, None, 1, 1, set(), {}, 3, 99, 4, 99]।

— পাইমে

Answer 5

ইটারটুলগুলি ছাড়াই এবং ধরে নেওয়া যায় যে l1 l2 এর চেয়ে 1 আইটেম লম্বা:

>>> sum(zip(l1, l2+[0]), ())[:-1]
('f', 'hello', 'o', 'world', 'o')

এরটুলগুলি ব্যবহার করে এবং ধরে নেওয়া যে তালিকার মধ্যে কোনওটি নেই:

>>> filter(None, sum(itertools.izip_longest(l1, l2), ()))
('f', 'hello', 'o', 'world', 'o')

Comments

এটি আমার প্রিয় উত্তর। এটা এত সংক্ষিপ্ত।

— mbomb007

@ anishtain4 পিন, তালিকা থেকে tuples যেমন উপাদানের জোড়া লাগে [(l1[0], l2[0]), (l1[1], l2[1]), ...]। sumএকত্রে টিপলসকে সম্মিলিত করে: (l1[0], l2[0]) + (l1[1], l2[1]) + ...যার ফলে আন্তঃবাহিত তালিকাগুলি তৈরি হয়। এক-লাইনের বাকি অংশটি জিপের জন্য অতিরিক্ত উপাদান সহ l1 এর প্যাডিং এবং সেই প্যাডিং থেকে মুক্তি পেতে -1 অবধি স্লাইস করা উচিত।

— Zart

izip_longest (পাইপথোন দীর্ঘ 3 পরে zip_longest) + [[0] প্যাডিং প্রয়োজন হয় না, যখন তালিকা দৈর্ঘ্যের তালিকাগুলি মেলে না তখন এটি স্পষ্টতই কোনওটি পূরণ করে না, যখন filter(None, ...( boolপরিবর্তে ব্যবহার করতে পারে , বা None.__ne__) 0, কিছুই নয় এবং খালি স্ট্রিং সহ মিথ্যা মানগুলি সরিয়ে দেয়, সুতরাং দ্বিতীয় প্রকাশটি কঠোরভাবে প্রথমটির সমতুল্য নয়।

— জার্ট

প্রশ্ন আপনি কীভাবে sumএটি করেছেন? সেখানে দ্বিতীয় যুক্তির ভূমিকা কী? নথিগুলিতে, দ্বিতীয় যুক্তিটি হ'ল start।

— anishtain4

শুরুর ডিফল্ট মান 0 হয় এবং আপনি 0+ (কিছু, টিপল) করতে পারবেন না, সুতরাং শুরুটি খালি টুপলে পরিবর্তিত হয়।

— জার্ট 16

Answer 6

আমি জানি প্রশ্নগুলি দুটি তালিকাগুলির বিষয়ে জিজ্ঞাসা করে যার মধ্যে একটির তুলনায় একটি আইটেম বেশি থাকে তবে আমি অনুভব করেছি যে আমি এই প্রশ্নটি অন্যদের জন্য রেখে দেব।

এখানে বিভিন্ন আকারের দুটি তালিকার সাথে কাজ করার জন্য ডানকের সমাধানটি রূপান্তরিত করা হয়েছে।

list1 = ['f', 'o', 'o', 'b', 'a', 'r']
list2 = ['hello', 'world']
num = min(len(list1), len(list2))
result = [None]*(num*2)
result[::2] = list1[:num]
result[1::2] = list2[:num]
result.extend(list1[num:])
result.extend(list2[num:])
result

এই ফলাফলগুলি:

['f', 'hello', 'o', 'world', 'o', 'b', 'a', 'r'] 

Answer 7

উভয় তালিকার সমান দৈর্ঘ্য থাকলে আপনি এটি করতে পারেন:

[x for y in zip(list1, list2) for x in y]

প্রথম তালিকায় আরও একটি উপাদান রয়েছে, আপনি এটি পোস্ট পোস্ট করতে পারেন:

[x for y in zip(list1, list2) for x in y] + [list1[-1]]

Comments

The এটির উত্তর হওয়া উচিত, গত 10 বছরে পাইথন আরও অজগর হয়ে উঠেছে

— তিয়ান

Answer 8

এখানে এটির জন্য একটি লাইন রয়েছে:

list3 = [ item for pair in zip(list1, list2 + [0]) for item in pair][:-1]

Comments

এটি সঠিকভাবে কাজ করে তবে আমাকে অযৌক্তিক হিসাবে আঘাত করে যেহেতু এত সহজ কিছু অর্জনের জন্য এটি এত কিছু করে। আমি বলছি না যে এই পদ্ধতির অদক্ষতা, কেবল এটি পড়া সহজ নয় particularly

— ডেভিডচেমার্স

Answer 9

def combine(list1, list2):
    lst = []
    len1 = len(list1)
    len2 = len(list2)

    for index in range( max(len1, len2) ):
        if index+1 <= len1:
            lst += [list1[index]]

        if index+1 <= len2:
            lst += [list2[index]]

    return lst

Comments

পরিবর্তনীয় ডিফল্ট তর্কগুলি ব্যবহার করার সময় খুব সাবধান হন। এটি কেবল প্রথমবার যখন ডাকা হবে তখনই সঠিক উত্তরটি ফিরে আসবে, কারণ এরপরে প্রতিটি কলের জন্য পুনরায় ব্যবহার করা হবে। এটি lst = কোনও হিসাবে আরও ভাল লেখা হবে ... যদি lst না হয় তবে: lst = [], যদিও আমি এখানে তালিকাভুক্ত অন্যদের চেয়ে এই পদ্ধতির বিকল্প বেছে নেওয়ার কোনও বাধ্যতামূলক কারণ দেখছি না।

— ডেভিডচেমার্স

lst ফাংশন মধ্যে সংজ্ঞায়িত করা হয় তাই স্থানীয় ভেরিয়েবল। সম্ভাব্য সমস্যাটি হ'ল তালিকার 1 এবং তালিকা 2 হ'ল প্রতিটি ফাংশনটি ব্যবহার করার সময় আপনি পুনরায় ব্যবহার করবেন, আপনি বিভিন্ন তালিকার সাথে ফাংশনটি কল করলেও। ডকস.পিথন.আর.

— টিউটোরিয়াল/…

@ ব্লোকলে: ভুল, এটি একত্রিত হলে পুনরায় ব্যবহার করা হবে (list1 = [...], list2 = [...])

— হত্যা করা হয়েছে

যখন এই সমাধানটি প্রথম পোস্ট করা হয়েছিল তখন তার প্রথম লাইনটি পড়ে def combine(list1, list2, lst=[]):, তাই আমার মন্তব্য। যতক্ষণ না আমি এই মন্তব্যটি জমা দিয়েছি ততক্ষণে হত্যাকাণ্ড প্রয়োজনীয় পরিবর্তন করেছে।

— ডেভিডচেম্বার

Answer 10

একাধিক আইটেমের বিকল্প গোষ্ঠীগুলির বিকল্পের সাথে এবং আউটপুটে সমস্ত আইটেম উপস্থিত রয়েছে কিনা তা নিশ্চিত করে উপরের কার্লোস ভ্যালিয়েন্টের অবদানের ভিত্তিতে এটি এক:

A=["a","b","c","d"]
B=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]

def cyclemix(xs, ys, n=1):
    for p in range(0,int((len(ys)+len(xs))/n)):
        for g in range(0,min(len(ys),n)):
            yield ys[0]
            ys.append(ys.pop(0))
        for g in range(0,min(len(xs),n)):
            yield xs[0]
            xs.append(xs.pop(0))

print [x for x in cyclemix(A, B, 3)]

এটি প্রতিটি এবং তিনটি মানের গ্রুপ দ্বারা A এবং B কে তালিকাভুক্ত করবে:

['a', 'b', 'c', 1, 2, 3, 'd', 'a', 'b', 4, 5, 6, 'c', 'd', 'a', 7, 8, 9, 'b', 'c', 'd', 10, 11, 12, 'a', 'b', 'c', 13, 14, 15]

Answer 11

কিছুটা দেরি হতে পারে আরও একটি পাইথন ওয়ান-লাইনার কিনুন। যখন দুটি তালিকার সমান বা অসম আকার থাকে তখন এটি কাজ করে। মূল্যহীন একটি জিনিস এটি a এবং b কে সংশোধন করবে। যদি এটি কোনও সমস্যা হয় তবে আপনাকে অন্যান্য সমাধানগুলি ব্যবহার করতে হবে।

a = ['f', 'o', 'o']
b = ['hello', 'world']
sum([[a.pop(0), b.pop(0)] for i in range(min(len(a), len(b)))],[])+a+b
['f', 'hello', 'o', 'world', 'o']

Answer 12

আমার গ্রহণ:

a = "hlowrd"
b = "el ol"

def func(xs, ys):
    ys = iter(ys)
    for x in xs:
        yield x
        yield ys.next()

print [x for x in func(a, b)]

Answer 13

তালিকা বোধগম্যতা ব্যবহার করে এখানে একটি লাইনার রয়েছে, ডাব্লু / ও অন্যান্য লাইব্রেরি:

list3 = [sub[i] for i in range(len(list2)) for sub in [list1, list2]] + [list1[-1]]

আপনি যদি আপনার প্রাথমিক তালিকা 1 টি পার্শ্ব প্রতিক্রিয়া অনুসারে পরিবর্তনের মঞ্জুরি দেন তবে এখানে আরও একটি পদ্ধতি রয়েছে:

[list1.insert((i+1)*2-1, list2[i]) for i in range(len(list2))]

Answer 14

from itertools import chain
list(chain(*zip('abc', 'def')))  # Note: this only works for lists of equal length
['a', 'd', 'b', 'e', 'c', 'f']

Answer 15

সংক্ষিপ্ততম স্থানে:

def interlace(*iters, next = next) -> collections.Iterable:
    """
    interlace(i1, i2, ..., in) -> (
        i1-0, i2-0, ..., in-0,
        i1-1, i2-1, ..., in-1,
        .
        .
        .
        i1-n, i2-n, ..., in-n,
    )
    """
    return map(next, cycle([iter(x) for x in iters]))

অবশ্যই, পরবর্তী / __ পরবর্তী__ পদ্ধতিটি সমাধান করা দ্রুততর হতে পারে।

Answer 16

এটি অদ্ভুত তবে তালিকাগুলির আকার যাই হোক না কেন তা কার্যকর করে:

list3 = [element for element in list(itertools.chain.from_iterable([val for val in itertools.izip_longest(list1, list2)])) if element != None]

Answer 17

অন্য প্রশ্নের উত্তর দ্বারা অনুপ্রাণিত একাধিক ওয়ান-লাইনার :

import itertools

list(itertools.chain.from_iterable(itertools.izip_longest(list1, list2, fillvalue=object)))[:-1]

[i for l in itertools.izip_longest(list1, list2, fillvalue=object) for i in l if i is not object]

[item for sublist in map(None, list1, list2) for item in sublist][:-1]

Answer 18

কেমন আজেবাজে? এটি স্ট্রিংগুলির সাথেও কাজ করে:

import numpy as np

np.array([[a,b] for a,b in zip([1,2,3],[2,3,4,5,6])]).ravel()

ফলাফল:

array([1, 2, 2, 3, 3, 4])

Answer 19

কার্যকরী এবং অপরিবর্তনীয় উপায়ে বিকল্প (পাইথন 3):

from itertools import zip_longest
from functools import reduce

reduce(lambda lst, zipped: [*lst, *zipped] if zipped[1] != None else [*lst, zipped[0]], zip_longest(list1, list2),[])

Answer 20

আমি সহজ করতাম:

chain.from_iterable( izip( list1, list2 ) )

এটি কোনও অতিরিক্ত স্টোরেজ প্রয়োজনীয়তা তৈরি না করেই একটি পুনরাবৃত্তকারী নিয়ে আসবে।

Comments

এটি সত্যিই সহজ, তবে এটি কেবল একই দৈর্ঘ্যের তালিকাগুলির সাথে কাজ করে!

— জোচেন রিটেল

chain.from_iterable(izip(list1, list2), list1[len(list2):])এখানে জিজ্ঞাসা করা বিশেষ সমস্যার জন্য আপনি এটি ঠিক করতে পারেন ... তালিকা 1 দীর্ঘতর হওয়ার কথা।

— জোচেন রিটজেল

হ্যাঁ তবে আমি বরং এমন একটি সমাধান নিয়ে এসেছি যা স্বেচ্ছাসেবী দৈর্ঘ্যের ধারকগুলির জন্য কাজ করে বা উপরে প্রস্তাবিত সমাধানগুলিতে ফল দেয়।

— Wheaties

Answer 21

আমি তালিকা বোধগম্য হতে না পেরে খুব বৃদ্ধ, তাই:

import operator
list3 = reduce(operator.add, zip(list1, list2))