নেস্টেড তালিকায় বোধগম্যতা তালিকাবদ্ধ করবেন?

Question

আমার এই নেস্টেড তালিকা রয়েছে:

l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']]

এখন, আমি যা করতে চাই তা হ'ল প্রতিটি উপাদানকে তালিকায় পরিবর্তন করতে। আমার সমাধানটি হ'ল:

newList = []
for x in l:
  for y in x:
    newList.append(float(y))

তবে নেস্টেড তালিকা বোঝার সাহায্যে এটি করা যায়, তাই না?

আমি যা করেছি তা হ'ল:

[float(y) for y in x for x in l]

তবে তারপরে ফলাফলটি 2400 এর যোগফল সহ 100 এর গুচ্ছ হয়।

কোন সমাধান, একটি ব্যাখ্যা অনেক প্রশংসা করা হবে। ধন্যবাদ!

Comments

আপনি কি এছাড়াও আপনার তালিকার চেপ্টা করতে চান?

— গ্রেগ হিউগিল

@ গ্রেগ হিউগিল: ওপি কোনও উত্তর দেয়নি, তবে তারা যে উত্তরটি গ্রহণ করেছে তার ভিত্তিতে মনে হয় তারা বাসা বাঁধে যেমন রাখতে চাইত।

— smci

Answer 1

নেস্টেড তালিকা বোঝার সাথে আপনি এখানে এটি কীভাবে করবেন:

[[float(y) for y in x] for x in l]

এটি আপনাকে তালিকার একটি তালিকা দেবে, আপনি স্ট্রিংয়ের পরিবর্তে ভাসা বাদ দিয়ে শুরু করেছিলেন what আপনি যদি একটি ফ্ল্যাট তালিকা চান তবে আপনি ব্যবহার করতে পারেন [float(y) for x in l for y in x]।

Answer 2

লুপের জন্য নেস্টেড তালিকা বোধগম্যকে কীভাবে রূপান্তর করবেন তা এখানে:

নেস্টেড তালিকা বোঝাপড়াটি কীভাবে কাজ করে তা এখানে:

            l a b c d e f
            ↓ ↓ ↓ ↓ ↓ ↓ ↓
In [1]: l = [ [ [ [ [ [ 1 ] ] ] ] ] ]
In [2]: for a in l:
   ...:     for b in a:
   ...:         for c in b:
   ...:             for d in c:
   ...:                 for e in d:
   ...:                     for f in e:
   ...:                         print(float(f))
   ...:                         
1.0

In [3]: [float(f)
         for a in l
   ...:     for b in a
   ...:         for c in b
   ...:             for d in c
   ...:                 for e in d
   ...:                     for f in e]
Out[3]: [1.0]

আপনার ক্ষেত্রে এটি কিছু এমন হবে।

In [4]: new_list = [float(y) for x in l for y in x]

Comments

সুপার দরকারী! এটি পরিষ্কার করে তোলে যে লুপগুলি (উপরে থেকে নীচে) জেনারেটরে বাম থেকে ডানদিকে অর্ডার করা হয়েছে। এটি স্পষ্ট নয় যেহেতু (f(x) for x in l)বামদিকে লুপ সমমানের দ্বিতীয় লাইনটি স্থানে places

— ব্যবহারকারীর 48956

এটি হ'ল একটি ব্যাখ্যা যা আসলে আমার সাথে বাড়িতে আঘাত করছে, আপনাকে ধন্যবাদ!

— ডগলাস প্লামলে

Answer 3

>>> l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']]
>>> new_list = [float(x) for xs in l for x in xs]
>>> new_list
[40.0, 20.0, 10.0, 30.0, 20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0, 30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0]

Answer 4

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

[float(y) for x in l for y in x]

নীতিটি হ'ল: লুপের জন্য নেস্টেড হিসাবে এটি লেখার জন্য আপনি একই ক্রমটি ব্যবহার করুন।

Comments

এটির উত্তরটি হওয়া উচিত, যেমনটি আমরা কয়েকবার বারবার বন্ধনী বানাতে চাই না

— জিংক করা উচিত

এটি সঠিক উত্তর নাও হতে পারে কারণ এটি একটি অনিচ্ছাকৃত তালিকাকে আউটপুট করে, তবে এটিই আমি খুঁজছিলাম, বিশেষত নীতিটি । ধন্যবাদ!

— রদ্রিগো ই। প্রিন্সিপ

Answer 5

যেহেতু আমি এখানে একটু দেরি করেছি তবে আমি কীভাবে তালিকা বোধশক্তিটি বিশেষভাবে নেস্টেড তালিকা বোঝার কাজ করে তা ভাগ করে নিতে চাই:

New_list= [[float(y) for x in l]

আসলে হিসাবে একই:

New_list=[]
for x in l:
    New_list.append(x)

এবং এখন নেস্টেড তালিকা অনুধাবন:

[[float(y) for y in x] for x in l]

হিসাবে একই;

new_list=[]
for x in l:
    sub_list=[]
    for y in x:
        sub_list.append(float(y))

    new_list.append(sub_list)

print(new_list)

আউটপুট:

[[40.0, 20.0, 10.0, 30.0], [20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0], [30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0], [100.0, 100.0], [100.0, 100.0, 100.0, 100.0, 100.0], [100.0, 100.0, 100.0, 100.0]]

Answer 6

যদি আপনি নেস্টেড তালিকার উপলব্ধি পছন্দ না করেন তবে আপনি মানচিত্রের কার্যকারিতাটিও ব্যবহার করতে পারেন ,

>>> from pprint import pprint

>>> l = l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']] 

>>> pprint(l)
[['40', '20', '10', '30'],
['20', '20', '20', '20', '20', '30', '20'],
['30', '20', '30', '50', '10', '30', '20', '20', '20'],
['100', '100'],
['100', '100', '100', '100', '100'],
['100', '100', '100', '100']]

>>> float_l = [map(float, nested_list) for nested_list in l]

>>> pprint(float_l)
[[40.0, 20.0, 10.0, 30.0],
[20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0],
[30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0],
[100.0, 100.0],
[100.0, 100.0, 100.0, 100.0, 100.0],
[100.0, 100.0, 100.0, 100.0]]

Comments

আপনার কোড তালিকার পরিবর্তে মানচিত্রের অবজেক্ট তৈরি করে: >>> float_l = [map(float, nested_list) for nested_list in l] [[<map at 0x47be9b0>], [<map at 0x47be2e8>], [<map at 0x47be4a8>], [<map at 0x47beeb8>], [<map at 0x484b048>], [<map at 0x484b0b8>]] তবে এটি প্রত্যাশা অনুযায়ী কাজ করতে তালিকার জন্য একটি অতিরিক্ত কল যুক্ত করে: >>> float_l = [list(map(float, nested_list)) for nested_list in l]

— পিক্সেলফেরেফট

@ পিক্সেলপারফেক্ট যা বোঝার বাইরে জেনারেটরগুলিতে ফিরতে ( ভুল তথ্য দেওয়া ..) পরিবর্তনের কারণে python3।

— জাভাদবা

Answer 7

সমাধান করার জন্য আমারও একই সমস্যা ছিল তাই আমি এই প্রশ্নটি জুড়ে এসেছি। আমি অ্যান্ড্রু ক্লার্ক এবং নারায়ণের উত্তরটির একটি পারফরম্যান্স তুলনা করেছি যা আমি ভাগ করতে চাই।

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

এটি আসলে সত্য কিনা তা দেখার জন্য একটি পারফরম্যান্স বেঞ্চমার্ক করি। এই সমস্ত পরীক্ষার জন্য আমি পাইথন সংস্করণ 3.5.0 ব্যবহার করেছি। পরীক্ষার প্রথম সেটটিতে আমি তালিকা অনুসারে উপাদানগুলিকে 10 হতে এবং 10-100,000 থেকে তালিকার সংখ্যা পরিবর্তিত করতে চাই

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*10]"
>>> 100000 loops, best of 3: 15.2 usec per loop   
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*10]"
>>> 10000 loops, best of 3: 19.6 usec per loop 

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*100]"
>>> 100000 loops, best of 3: 15.2 usec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*100]"
>>> 10000 loops, best of 3: 19.6 usec per loop 

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*1000]"
>>> 1000 loops, best of 3: 1.43 msec per loop   
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*1000]"
>>> 100 loops, best of 3: 1.91 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*10000]"
>>> 100 loops, best of 3: 13.6 msec per loop   
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*10000]"
>>> 10 loops, best of 3: 19.1 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*100000]"
>>> 10 loops, best of 3: 164 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*100000]"
>>> 10 loops, best of 3: 216 msec per loop

পরের পরীক্ষার সেটগুলিতে আমি তালিকাগুলির তালিকাগুলির সংখ্যা 100 করে বাড়িয়ে দিতে চাই ।

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*10]"
>>> 10000 loops, best of 3: 110 usec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*10]"
>>> 10000 loops, best of 3: 151 usec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*100]"
>>> 1000 loops, best of 3: 1.11 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*100]"
>>> 1000 loops, best of 3: 1.5 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*1000]"
>>> 100 loops, best of 3: 11.2 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*1000]"
>>> 100 loops, best of 3: 16.7 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*10000]"
>>> 10 loops, best of 3: 134 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*10000]"
>>> 10 loops, best of 3: 171 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*100000]"
>>> 10 loops, best of 3: 1.32 sec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*100000]"
>>> 10 loops, best of 3: 1.7 sec per loop

সাহসী পদক্ষেপ নিতে এবং তালিকার উপাদানগুলির সংখ্যা 1000 হতে সংশোধন করতে দেয়

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*10]"
>>> 1000 loops, best of 3: 800 usec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*10]"
>>> 1000 loops, best of 3: 1.16 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*100]"
>>> 100 loops, best of 3: 8.26 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*100]"
>>> 100 loops, best of 3: 11.7 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*1000]"
>>> 10 loops, best of 3: 83.8 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*1000]"
>>> 10 loops, best of 3: 118 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*10000]"
>>> 10 loops, best of 3: 868 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*10000]"
>>> 10 loops, best of 3: 1.23 sec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*100000]"
>>> 10 loops, best of 3: 9.2 sec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*100000]"
>>> 10 loops, best of 3: 12.7 sec per loop

এই পরীক্ষা থেকে আমরা উপসংহারে পৌঁছাতে পারি যে mapএই ক্ষেত্রে তালিকা বোঝার চেয়ে একটি কার্যকারিতা উপকার রয়েছে। আপনি intবা অন্যটিতে কাস্ট করার চেষ্টা করছেন তবে এটি প্রযোজ্য str। প্রতি লিস্টে কম উপাদান সহ ছোট সংখ্যক তালিকার জন্য, পার্থক্য নগণ্য। প্রতি তালিকায় আরও বেশি উপাদান সহ বৃহত তালিকার mapজন্য তালিকার বোধগম্যতার পরিবর্তে কেউ ব্যবহার করতে পছন্দ করতে পারে তবে এটি অ্যাপ্লিকেশন প্রয়োজনীয়তার উপর সম্পূর্ণ নির্ভর করে।

তবে আমি ব্যক্তিগতভাবে তালিকার সংজ্ঞাটি এর চেয়ে বেশি পঠনযোগ্য এবং মূ .় বলে মনে করি map। এটি পাইথনের একটি ডি-ফ্যাক্টো স্ট্যান্ডার্ড। সাধারণত লোকেরা তালিকার বোধগম্যতার চেয়ে বেশি দক্ষ এবং আরামদায়ক (বিশেষত শিক্ষানবিশ) map।

Answer 8

হ্যাঁ, আপনি এই জাতীয় কোড দিয়ে এটি করতে পারেন:

l = [[float(y) for y in x] for x in l]

Comments

[float(y) for y in x for x in l]এটি

— 2400 এর

Answer 9

এই সমস্যাটি লুপের জন্য ব্যবহার না করেই সমাধান করা যায় S একক লাইন কোড এর জন্য যথেষ্ট। ল্যাম্বদা ফাংশন সহ নেস্টেড ম্যাপ ব্যবহার করা এখানেও কাজ করবে।

l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']]

map(lambda x:map(lambda y:float(y),x),l)

এবং আউটপুট তালিকা নীচে হবে:

[[40.0, 20.0, 10.0, 30.0], [20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0], [30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0], [100.0, 100.0], [100.0, 100.0, 100.0, 100.0, 100.0], [100.0, 100.0, 100.0, 100.0]]

Comments

@ অ্যান্ড্রু ক্লার্ক বা হ্যারি বিনসওয়ানজারের সমাধানগুলি (আরও ভ্যানিলা তালিকার উপলব্ধি) বলতে কি ল্যাম্বডাসের কোনও কার্যকারিতা রয়েছে? লাম্বদাস যেমন পড়া শক্ত মনে হয় তেমন।

— স্টিফানজেক্লেয়ার 13

Answer 10

আমার মতে এটি করার সর্বোত্তম উপায় হ'ল পাইথনের itertoolsপ্যাকেজটি ব্যবহার করা ।

>>>import itertools
>>>l1 = [1,2,3]
>>>l2 = [10,20,30]
>>>[l*2 for l in itertools.chain(*[l1,l2])]
[2, 4, 6, 20, 40, 60]

Answer 11

হ্যাঁ আপনি নিম্নলিখিত করতে পারেন।

[[float(y) for y in x] for x in l]

Answer 12

    deck = [] 
    for rank in ranks:
        for suit in suits:
            deck.append(('%s%s')%(rank, suit))

তালিকা অনুধাবন ব্যবহার করে এটি অর্জন করা যেতে পারে:

[deck.append((rank,suit)) for suit in suits for rank in ranks ]

Comments

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

— বাউম মিট অজেন

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

— ফিল্নার

তালিকা বোধগম্যতা ব্যবহার করে লুপের জন্য নেস্টেড,

— এডিটি কুমার

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

— বাযুমের Augen MIT