পাইথন: শর্তের ভিত্তিতে একটি তালিকা বিভক্ত করবেন?

Question

শর্তাধীনের ভিত্তিতে আইটেমের তালিকাটিকে একাধিক তালিকায় বিভক্ত করার জন্য নান্দনিকভাবে এবং পারফরম্যান্সের দৃষ্টিভঙ্গি থেকে সবচেয়ে ভাল উপায় কী? সমতুল্য:

good = [x for x in mylist if x in goodvals]
bad  = [x for x in mylist if x not in goodvals]

এটি করার জন্য আরও কি মার্জিত উপায় আছে?

আপডেট: আমি কী করতে চাইছি তা আরও ভালভাবে বোঝাতে এখানে আসল ব্যবহারের কেস:

# files looks like: [ ('file1.jpg', 33L, '.jpg'), ('file2.avi', 999L, '.avi'), ... ]
IMAGE_TYPES = ('.jpg','.jpeg','.gif','.bmp','.png')
images = [f for f in files if f[2].lower() in IMAGE_TYPES]
anims  = [f for f in files if f[2].lower() not in IMAGE_TYPES]

Comments

সেট নির্মাতার বিবৃতিতে শর্ত রাখার উপায় সন্ধান করতে এখানে অবতরণ করেছেন, আপনার প্রশ্নের

— উত্তরটি

বিভাজন এই অপারেশনটির দুর্ভাগ্যজনক বর্ণনা, কারণ পাইথন স্ট্রিংয়ের সাথে ইতিমধ্যে এর একটি নির্দিষ্ট অর্থ রয়েছে। আমি মনে করি ডিভাইড একটি আরো সঠিক (বা অন্তত কম পাইথন iterables প্রেক্ষাপটে ওভারলোড এ) শব্দ এই অপারেশন বর্ণনা করা হয়। আমি ক্রমান্বয়ে উপ-তালিকাগুলির আদেশকৃত সংকলনে তালিকাটিকে বিভক্তstr.split() করতে সমতুল্য তালিকার সন্ধান করতে এখানে অবতরণ করেছি । উদাহরণস্বরূপ , তালিকার উপাদানগুলিকে বিভাগ অনুসারে বিভক্ত করার বিপরীতে । split([1,2,3,4,5,3,6], 3) -> ([1,2],[4,5],[6])

— স্টিউ

অজগর-তালিকায় একই বিষয়ে আলোচনা ।

— জিয়াং চিয়ামিভ

IMAGE_TYPES একটি tuple পরিবর্তে একটি সেট হওয়া উচিত: IMAGE_TYPES = set('.jpg','.jpeg','.gif','.bmp','.png')। n (1) এর পরিবর্তে এন (ও / 2) এর পরিবর্তে পাঠযোগ্যতার কোনও পার্থক্য নেই।

— চেইমজি

Answer 1

good = [x for x in mylist if x in goodvals]
bad  = [x for x in mylist if x not in goodvals]

এটি করার জন্য আরও কি মার্জিত উপায় আছে?

এই কোডটি নিখুঁতভাবে পঠনযোগ্য এবং অত্যন্ত স্পষ্ট!

# files looks like: [ ('file1.jpg', 33L, '.jpg'), ('file2.avi', 999L, '.avi'), ... ]
IMAGE_TYPES = ('.jpg','.jpeg','.gif','.bmp','.png')
images = [f for f in files if f[2].lower() in IMAGE_TYPES]
anims  = [f for f in files if f[2].lower() not in IMAGE_TYPES]

আবারও ঠিক আছে!

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

আসলে, আমি আরও একটি পদক্ষেপ "পিছিয়ে" যেতে পারি এবং লুপের জন্য কেবল একটি সাধারণ ব্যবহার করতে পারি:

images, anims = [], []

for f in files:
    if f.lower() in IMAGE_TYPES:
        images.append(f)
    else:
        anims.append(f)

তালিকা-বোধগম্যতা বা ব্যবহারটি set()ঠিক আছে যতক্ষণ না আপনার কিছু অন্য চেক বা যুক্তি যুক্ত করার দরকার হয় - বলুন যে আপনি সমস্ত 0-বাইট জেপিগ অপসারণ করতে চান, আপনি ঠিক তেমন কিছু যুক্ত করুন ..

if f[1] == 0:
    continue

Comments

তালিকার দু'বার লুপ না করে কোনও তালিকা বোঝার উপায় নেই?

— বালকি

সমস্যাটি হ'ল এটি DRY নীতি লঙ্ঘন করে। এটি করার আরও ভাল উপায় থাকলে ভাল লাগবে।

— অ্যান্টিমনি

ফাংশনাল প্রোগ্রামিং (হাস্কেল), বা ফাংশনাল স্টাইল (লিনকুই) এর ক্ষুধা উঠলে আমরা তার বয়সের জন্য পাইথনকে গন্ধ পেতে শুরু করি [x for x in blah if ...]- ভার্জোজ, lambdaআনাড়ি এবং সীমাবদ্ধ ... এটি 1995 থেকে আজ পর্যন্ত দুর্দান্ত গাড়ি চালানোর মতো অনুভব করে। তখনকার মতো নয়।

— টমাসজ গ্যান্ডোর

@ টমাসজান্ডার এফটিআর, হাস্কেল পাইথনের চেয়ে বয়স্ক (এবং প্রকৃতপক্ষে এর নকশাকে প্রভাবিত করেছেন)। আমি মনে করি তালিকা বোধগম্যতা এবং ল্যাম্বডাসের বাক্য গঠনটি ইচ্ছাকৃতভাবে ভার্ভোজের দিকে কিছুটা রাখা হয়েছিল, সম্ভবত এগুলি অত্যধিক ব্যবহারকে নিরুৎসাহিত করার জন্য। যা আসলেই কিছুটা ঝুঁকিপূর্ণ ... আমি যতটা হাস্কেলকে পছন্দ করি, আমি দেখতে পাচ্ছি যে কেন অনেকে পাইথনকে সাধারণত বেশি পঠনযোগ্য বলে মনে করেন।

— বাম দিকের বাইরে

লুপের জন্য সহজ হ'ল এটি করার সর্বোত্তম উপায় ... একটি একক লুপ, খুব স্পষ্ট এবং পঠনযোগ্য

— Anentropic

Answer 2

good, bad = [], []
for x in mylist:
    (bad, good)[x in goodvals].append(x)

Comments

এটি অবিশ্বাস্যভাবে উদ্ভাবনী! কী ঘটছে তা বুঝতে আমার কিছুটা সময় লেগেছে। আমি যদি জানতে চাই যে অন্যেরাও এটি পড়ার যোগ্য কোড হিসাবে বিবেচনা করা যায় কি না।

— jgpaiva

good.append(x) if x in goodvals else bad.append(x)আরও পাঠযোগ্য।

— ডানসালমো

@ ডানসালমো বিশেষত যেহেতু আপনি এটিকে চক্রের সাহায্যে ওয়ান-লাইনার তৈরি করতে পারেন এবং আপনি যদি এর থেকে আরও জটিল কিছু যুক্ত করতে চান তবে আপনি কেবল xএটির মধ্যে তৈরি করতে পারেন append:for x in mylist: (good if isgood(x) else bad).append(x)

— yo '

@ এমলেট, সেক্ষেত্রে আপনার সম্ভবত বৈশিষ্ট্যটির অনুসন্ধান অন্তর্ভুক্ত করা উচিত(bad.append, good.append)

— জন লা রুই

কিছুটা সংক্ষিপ্ততর প্রকরণ:(good if x in goodvals else bad).append(x)

— পাই ডিলপোর্ট

Answer 3

এখানে অলস পুনরুক্তি পদ্ধতি:

from itertools import tee

def split_on_condition(seq, condition):
    l1, l2 = tee((condition(item), item) for item in seq)
    return (i for p, i in l1 if p), (i for p, i in l2 if not p)

এটি প্রতি আইটেমের জন্য শর্তটি একবার মূল্যায়ন করে এবং দুটি জেনারেটর প্রদান করে, প্রথমে শর্তটি যেখানে সঠিক তা ক্রম থেকে মান দেয়, অন্যটি যেখানে এটি মিথ্যা।

কারণ এটি অলস আপনি এটি কোনও পুনরুক্তিকারী এমনকি এমনকী একটি অনন্তরও ব্যবহার করতে পারেন:

from itertools import count, islice

def is_prime(n):
    return n > 1 and all(n % i for i in xrange(2, n))

primes, not_primes = split_on_condition(count(), is_prime)
print("First 10 primes", list(islice(primes, 10)))
print("First 10 non-primes", list(islice(not_primes, 10)))

সাধারণত অ-অলস তালিকার রিটার্নিং পদ্ধতির চেয়ে ভাল:

def split_on_condition(seq, condition):
    a, b = [], []
    for item in seq:
        (a if condition(item) else b).append(item)
    return a, b

সম্পাদনা করুন: কিছু কী দ্বারা বিভিন্ন তালিকায় আইটেমগুলি বিভক্ত করার জন্য আপনার আরও সুনির্দিষ্ট ব্যবহারের জন্য, একটি জেনেরিক ফাংশন রয়েছে যা এটি করে:

DROP_VALUE = lambda _:_
def split_by_key(seq, resultmapping, keyfunc, default=DROP_VALUE):
    """Split a sequence into lists based on a key function.

        seq - input sequence
        resultmapping - a dictionary that maps from target lists to keys that go to that list
        keyfunc - function to calculate the key of an input value
        default - the target where items that don't have a corresponding key go, by default they are dropped
    """
    result_lists = dict((key, []) for key in resultmapping)
    appenders = dict((key, result_lists[target].append) for target, keys in resultmapping.items() for key in keys)

    if default is not DROP_VALUE:
        result_lists.setdefault(default, [])
        default_action = result_lists[default].append
    else:
        default_action = DROP_VALUE

    for item in seq:
        appenders.get(keyfunc(item), default_action)(item)

    return result_lists

ব্যবহার:

def file_extension(f):
    return f[2].lower()

split_files = split_by_key(files, {'images': IMAGE_TYPES}, keyfunc=file_extension, default='anims')
print split_files['images']
print split_files['anims']

Comments

আপনি সম্ভবত ঠিক বলেছেন যে এটি YAGNI নীতি লঙ্ঘন করে। এটি এই ধারণার উপর ভিত্তি করে তৈরি করা হয়েছে যে বিভিন্ন তালিকাতে জিনিসগুলি ভাগ করা যায় যা ভবিষ্যতে বৃদ্ধি পাবে।

— আন্টস আসমা

এটি অনেক কোড হতে পারে তবে যদি [ x for x in my_list if ExpensiveOperation(x) ]এটি চালাতে দীর্ঘ সময় নেয় তবে আপনি অবশ্যই এটি দুটিবার করতে চান না!

— ড্যাশ-টম-ব্যাং

পুনরাবৃত্ত-ভিত্তিক এবং একটি নির্দিষ্ট "এক্স" সমাধান সহ একাধিক প্রকারের অফার করার জন্য +1। ওপির "শুভেচ্ছাসমূহ" ছোট হতে পারে তবে এটির পরিবর্তে খুব বড় অভিধান বা ব্যয়বহুল শিকারী ব্যয়বহুল হতে পারে। এছাড়াও এটিকে তালিকা ধী দুইবার লিখতে প্রয়োজন হ্রাস সর্বত্র এটা দরকার এইভাবে টাইপস / ব্যবহারকারী ত্রুটি প্রবর্তনের জন্য সম্ভাবনা কমে যায়। সুন্দর সমাধান। ধন্যবাদ!

— cod3monk3y

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

— জন লা রুই

Answer 4

সমস্ত প্রস্তাবিত সমাধানগুলির সাথে সমস্যা হ'ল এটি ফিল্টারিং ফাংশনটি দু'বার স্ক্যান করে প্রয়োগ করবে। আমি এর মতো একটি সাধারণ ছোট ফাংশন করব:

def SplitIntoTwoLists(l, f):
  a = []
  b = []
  for i in l:
    if f(i):
      a.append(i)
    else:
      b.append(i)
 return (a,b)

এইভাবে আপনি দু'বার কোনও প্রক্রিয়া করছেন না এবং কোড পুনরাবৃত্তিও করছেন না।

Comments

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

— ম্যাথু ফ্ল্যাশেন

আইএমএইচও, আপনি যদি কম সিপিইউ ব্যবহারের সাথে এটি করার কোনও উপায় জানেন (এবং এভাবে বিদ্যুতের ড্রেন কম থাকে) তবে এটি ব্যবহার না করার কোনও কারণ নেই।

— 4'09 বাতাস

@ উইন্ডেন ... আমার সমস্ত পাইথন সিটিতে পোর্টিং;)

— এলিয়ট ক্যামেরন

Answer 5

আমার এটা নিতে। আমি একটি অলস, একক-পাস, partitionফাংশন প্রস্তাব করি যা আউটপুট উপকণাগুলিতে আপেক্ষিক ক্রম সংরক্ষণ করে।

1. প্রয়োজনীয়তা

আমি ধরে নিই যে প্রয়োজনীয়তাগুলি হ'ল:

• উপাদানগুলির আপেক্ষিক ক্রম বজায় রাখুন (অতএব, কোনও সেট এবং অভিধান নেই)
• প্রতিটি উপাদানগুলির জন্য একবারের জন্য শর্তটি মূল্যায়ন করুন (সুতরাং ব্যবহার করে না i) ( ) filterবা groupby)
• উভয় ক্রম অলস গ্রাহনের জন্য অনুমতি (যদি আমরা তাদের প্রাক্কলন সামর্থ্য করতে পারি, তবে নির্লজ্জ বাস্তবায়ন সম্ভবত গ্রহণযোগ্য হবে)

2. splitগ্রন্থাগার

আমার partitionফাংশন (নীচে প্রবর্তিত) এবং অন্যান্য অনুরূপ ফাংশন এটিকে একটি ছোট লাইব্রেরিতে পরিণত করেছে:

• পাইথন-বিভক্ত

এটি পিপিআই এর মাধ্যমে সাধারণত ইনস্টলযোগ্য:

pip install --user split

শর্তে একটি তালিকা বেসকে বিভক্ত করতে, partitionফাংশনটি ব্যবহার করুন:

>>> from split import partition
>>> files = [ ('file1.jpg', 33L, '.jpg'), ('file2.avi', 999L, '.avi') ]
>>> image_types = ('.jpg','.jpeg','.gif','.bmp','.png')
>>> images, other = partition(lambda f: f[-1] in image_types, files)
>>> list(images)
[('file1.jpg', 33L, '.jpg')]
>>> list(other)
[('file2.avi', 999L, '.avi')]

3. partitionফাংশন ব্যাখ্যা

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

from collections import deque

SplitSeq শ্রেণি গৃহকর্মের যত্ন নেয়:

class SplitSeq:
    def __init__(self, condition, sequence):
        self.cond = condition
        self.goods = deque([])
        self.bads = deque([])
        self.seq = iter(sequence)

যাদুটি তার .getNext()পদ্ধতিতে ঘটে । এটি প্রায়শই .next() পুনরুক্তির মতো, তবে আমরা এবার কোন ধরণের উপাদান চাই তা নির্দিষ্ট করার অনুমতি দেয়। দৃশ্যের পিছনে এটি প্রত্যাখ্যাত উপাদানগুলিকে ফেলে দেয় না, বরং তাদের দুটি কাতারে একটিতে রাখে:

    def getNext(self, getGood=True):
        if getGood:
            these, those, cond = self.goods, self.bads, self.cond
        else:
            these, those, cond = self.bads, self.goods, lambda x: not self.cond(x)
        if these:
            return these.popleft()
        else:
            while 1: # exit on StopIteration
                n = self.seq.next()
                if cond(n):
                    return n
                else:
                    those.append(n)

শেষ ব্যবহারকারীর partitionফাংশনটি ব্যবহার করার কথা । এটি একটি শর্ত ফাংশন এবং একটি ক্রম নেয় (ঠিক যেমন mapবা এর মতো filter), এবং দুটি জেনারেটর প্রদান করে। প্রথম জেনারেটর শর্তটি ধারণ করে এমন উপাদানগুলির একটি উপসর্গ তৈরি করে, দ্বিতীয়টি পরিপূরক উপসূচি তৈরি করে। ইলেটর এবং জেনারেটরগুলি এমনকি দীর্ঘ বা অসীম অনুক্রমের অলস বিভাজনের জন্য অনুমতি দেয়।

def partition(condition, sequence):
    cond = condition if condition else bool  # evaluate as bool if condition == None
    ss = SplitSeq(cond, sequence)
    def goods():
        while 1:
            yield ss.getNext(getGood=True)
    def bads():
        while 1:
            yield ss.getNext(getGood=False)
    return goods(), bads()

আমি ভবিষ্যতে আংশিক প্রয়োগের সুবিধার্থে প্রথম যুক্তি হিসাবে টেস্ট ফাংশনটি বেছে নিয়েছি ( প্রথম যুক্তি হিসাবে পরীক্ষা ফাংশনটি কীভাবে mapএবং filterএর মতো)।

Answer 6

আমি মূলত অ্যান্ডার্সের পদ্ধতির পছন্দ করি কারণ এটি খুব সাধারণ। এখানে এমন একটি সংস্করণ যা শ্রেণিবদ্ধকারীকে প্রথমে রাখে (ফিল্টার সিনট্যাক্সের সাথে মেলে) এবং একটি ডিফল্টডিক্ট্ট (আমদানি করা অনুমান) ব্যবহার করে।

def categorize(func, seq):
    """Return mapping from categories to lists
    of categorized items.
    """
    d = defaultdict(list)
    for item in seq:
        d[func(item)].append(item)
    return d

Comments

আমি পাইথনের জেনের যে বিবৃতিগুলি এখানে প্রয়োগ করা হয়েছে তা থেকে বের করার চেষ্টা করতে যাচ্ছিলাম , তবে এটির মন্তব্যের পক্ষে এটি অনেক বেশি। =) কোডের দুর্দান্ত উপাদান।

— jpmc26

Answer 7

প্রথমে যান (প্রাক-ওপি-সম্পাদনা): সেটগুলি ব্যবহার করুন:

mylist = [1,2,3,4,5,6,7]
goodvals = [1,3,7,8,9]

myset = set(mylist)
goodset = set(goodvals)

print list(myset.intersection(goodset))  # [1, 3, 7]
print list(myset.difference(goodset))    # [2, 4, 5, 6]

এটি পাঠযোগ্যতা (আইএমএইচও) এবং পারফরম্যান্স উভয়ের জন্যই ভাল।

দ্বিতীয় গো (ওপ-সম্পাদনা পরবর্তী):

সেট হিসাবে আপনার ভাল এক্সটেনশনের তালিকা তৈরি করুন:

IMAGE_TYPES = set(['.jpg','.jpeg','.gif','.bmp','.png'])

এবং এটি কর্মক্ষমতা বাড়িয়ে তুলবে। নাহলে আপনার যা আছে তা আমার কাছে ভাল লাগছে।

Comments

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

— দানিয়ার

এটি কি নকল মুছে ফেলবে না?

— mavnn

একটি সেট তৈরি করা হচ্ছে ও (এন লগ এন)। দু'বার তালিকাটি চিহ্নিত করা হ'ল ও (এন)। সেট সমাধানটি আরও মার্জিত হতে পারে (যখন এটি প্রথম স্থানে সঠিক থাকে) তবে এন বৃদ্ধি পাওয়ায় অবশ্যই ধীর হয়।

— ড্যাশ-টম-ব্যাং

@ ড্যাশ-টম-ব্যাং তালিকাটি হ'ল ও (এন * এন)। এর কারণ তালিকার প্রতিটি আইটেমের প্রতিটি আইটেমের সাথে তুলনা করা প্রয়োজন goodvals।

— চেইমজি 25'19

@ ছাইমজি ভাল পয়েন্ট, যদিও আমাদের ছেদ ও পার্থক্যমূলক ক্রিয়াকলাপগুলির ব্যয়ও বিবেচনা করা দরকার (যা আমি জানি না তবে তারাও সুপারলাইনার আমি যথেষ্ট নিশ্চিত)।

— ড্যাশ-টম-ব্যাং

Answer 8

itertools.groupby আপনি যা চান তা প্রায় কাজ করে, কেবল আপনি একক সঙ্গতিপূর্ণ পরিসীমা পান তা নিশ্চিত করার জন্য আইটেমগুলি বাছাই করা প্রয়োজন, সুতরাং আপনাকে প্রথমে আপনার কী অনুসারে বাছাই করতে হবে (অন্যথায় আপনি প্রতিটি ধরণের জন্য একাধিক আন্তঃবিস্তারিত দল পাবেন)। যেমন।

def is_good(f):
    return f[2].lower() in IMAGE_TYPES

files = [ ('file1.jpg', 33L, '.jpg'), ('file2.avi', 999L, '.avi'), ('file3.gif', 123L, '.gif')]

for key, group in itertools.groupby(sorted(files, key=is_good), key=is_good):
    print key, list(group)

দেয়:

False [('file2.avi', 999L, '.avi')]
True [('file1.jpg', 33L, '.jpg'), ('file3.gif', 123L, '.gif')]

অন্যান্য সমাধানগুলির মতো, কী ফানকে আপনি যে কোনও সংখ্যক গ্রুপে বিভক্ত করতে সংজ্ঞায়িত করা যেতে পারে।

Answer 9

good.append(x) if x in goodvals else bad.append(x)

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

সম্পূর্ণ উদাহরণ:

good, bad = [], []
for x in my_list:
    good.append(x) if x in goodvals else bad.append(x)

Answer 10

আপনি যদি এফপি স্টাইলে এটি তৈরি করতে চান:

good, bad = [ sum(x, []) for x in zip(*(([y], []) if y in goodvals else ([], [y])
                                        for y in mylist)) ]

সর্বাধিক পঠনযোগ্য সমাধান নয়, তবে কমপক্ষে একবারে আমার তালিকার মাধ্যমে পুনরাবৃত্তি হবে।

Comments

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

— rlat

Answer 11

ব্যক্তিগতভাবে, আপনার কাছে ইতিমধ্যে goodvalsঝুলন্ত তালিকা রয়েছে বলে ধরে নিলাম, আপনার দ্বারা উদ্ধৃত সংস্করণটি আমি পছন্দ করি । যদি না হয় তবে এর মতো কিছু:

good = filter(lambda x: is_good(x), mylist)
bad = filter(lambda x: not is_good(x), mylist)

অবশ্যই, এটি আপনার মতো তালিকার বোধগম্যতার সাথে ব্যবহার করার মতই একই রকম, তবে দেখার পরিবর্তে একটি ফাংশন সহ:

good = [x for x in mylist if is_good(x)]
bad  = [x for x in mylist if not is_good(x)]

সাধারণভাবে, আমি তালিকা বোধের নান্দনিকতা খুব আনন্দদায়ক বলে মনে করি। অবশ্যই, আপনি আসলে ক্রম সংরক্ষণ করা প্রয়োজন হবে না যদি এবং ব্যবহার সদৃশ প্রয়োজন হবে না, intersectionএবং differenceসেটে পদ্ধতি ভাল খুব কাজ করে।

Comments

অবশ্যই, filter(lambda x: is_good(x), mylist)হ্রাস করা যেতে পারেfilter(is_good, mylist)

— রব্রু

অতিরিক্ত ফাংশন কল যোগ করার পরে তালিকাটি বোঝার সাথে তুলনামূলকভাবে বাস্তবায়নের সময়টিকে দ্বিগুণ (!) করা হয়েছে যা আমি প্রোফাইলিংয়ে দেখেছি। বেশিরভাগ সময় তালিকা অনুধাবনকে পরাভূত করা শক্ত।

— করলি ব্রিগম্যান

Answer 12

আমি মনে করি এন অবস্থার উপর ভিত্তি করে একটি পুনরাবৃত্তীয় বিভক্তকরণের সাধারণীকরণ হ'ল সহজ

from collections import OrderedDict
def partition(iterable,*conditions):
    '''Returns a list with the elements that satisfy each of condition.
       Conditions are assumed to be exclusive'''
    d= OrderedDict((i,list())for i in range(len(conditions)))        
    for e in iterable:
        for i,condition in enumerate(conditions):
            if condition(e):
                d[i].append(e)
                break                    
    return d.values()

এই ক্ষেত্রে:

ints,floats,other = partition([2, 3.14, 1, 1.69, [], None],
                              lambda x: isinstance(x, int), 
                              lambda x: isinstance(x, float),
                              lambda x: True)

print " ints: {}\n floats:{}\n other:{}".format(ints,floats,other)

 ints: [2, 1]
 floats:[3.14, 1.69]
 other:[[], None]

যদি উপাদানটি একাধিক শর্ত পূরণ করতে পারে তবে বিরতিটি সরিয়ে ফেলুন।

Answer 13

def partition(pred, iterable):
    'Use a predicate to partition entries into false entries and true entries'
    # partition(is_odd, range(10)) --> 0 2 4 6 8   and  1 3 5 7 9
    t1, t2 = tee(iterable)
    return filterfalse(pred, t1), filter(pred, t2)

পরীক্ষা করে দেখুন এই

Answer 14

কখনও কখনও, দেখে মনে হয় তালিকার বোঝাপড়া ব্যবহার করা সবচেয়ে ভাল জিনিস নয়!

লোকেরা এ বিষয়ে দেওয়া উত্তরের ভিত্তিতে আমি একটি সামান্য পরীক্ষা করেছি, একটি এলোমেলোভাবে উত্পন্ন তালিকায় পরীক্ষিত। এখানে তালিকার প্রজন্মটি এখানে রয়েছে (সম্ভবত এটি করার আরও ভাল উপায় আছে তবে এটি বিন্দু নয়):

good_list = ('.jpg','.jpeg','.gif','.bmp','.png')

import random
import string
my_origin_list = []
for i in xrange(10000):
    fname = ''.join(random.choice(string.lowercase) for i in range(random.randrange(10)))
    if random.getrandbits(1):
        fext = random.choice(good_list)
    else:
        fext = "." + ''.join(random.choice(string.lowercase) for i in range(3))

    my_origin_list.append((fname + fext, random.randrange(1000), fext))

এবং এখানে আমরা যেতে

# Parand
def f1():
    return [e for e in my_origin_list if e[2] in good_list], [e for e in my_origin_list if not e[2] in good_list]

# dbr
def f2():
    a, b = list(), list()
    for e in my_origin_list:
        if e[2] in good_list:
            a.append(e)
        else:
            b.append(e)
    return a, b

# John La Rooy
def f3():
    a, b = list(), list()
    for e in my_origin_list:
        (b, a)[e[2] in good_list].append(e)
    return a, b

# Ants Aasma
def f4():
    l1, l2 = tee((e[2] in good_list, e) for e in my_origin_list)
    return [i for p, i in l1 if p], [i for p, i in l2 if not p]

# My personal way to do
def f5():
    a, b = zip(*[(e, None) if e[2] in good_list else (None, e) for e in my_origin_list])
    return list(filter(None, a)), list(filter(None, b))

# BJ Homer
def f6():
    return filter(lambda e: e[2] in good_list, my_origin_list), filter(lambda e: not e[2] in good_list, my_origin_list)

ছিমছাম ফাংশনটি ব্যবহার করে , সেরা ফলাফলটি ডিব্রির উত্তর:

f1     204/s  --    -5%   -14%   -15%   -20%   -26%
f6     215/s     6%  --    -9%   -11%   -16%   -22%
f3     237/s    16%    10%  --    -2%    -7%   -14%
f4     240/s    18%    12%     2%  --    -6%   -13%
f5     255/s    25%    18%     8%     6%  --    -8%
f2     277/s    36%    29%    17%    15%     9%  --

Comments

আপডেট হওয়া মানদণ্ডের সাথে এখানে দ্রুততর ফাংশন ।

— চেইমজি

Answer 15

তবুও এই সমস্যার আর একটি সমাধান। আমার একটি সমাধান প্রয়োজন যা দ্রুত সম্ভব। তার মানে তালিকার উপরে কেবলমাত্র একটি পুনরাবৃত্তি এবং ফলাফলের তালিকার একটিতে ডেটা যুক্ত করার জন্য পছন্দসই ও (1)। এটি সাস্টানিন দ্বারা প্রদত্ত সমাধানের সাথে খুব সংক্ষিপ্ত, বাদে খুব কম:

from collections import deque

def split(iterable, function):
    dq_true = deque()
    dq_false = deque()

    # deque - the fastest way to consume an iterator and append items
    deque((
      (dq_true if function(item) else dq_false).append(item) for item in iterable
    ), maxlen=0)

    return dq_true, dq_false

তারপরে, আপনি নিম্নলিখিত পদ্ধতিতে ফাংশনটি ব্যবহার করতে পারেন:

lower, higher = split([0,1,2,3,4,5,6,7,8,9], lambda x: x < 5)

selected, other = split([0,1,2,3,4,5,6,7,8,9], lambda x: x in {0,4,9})

তুমি কি জরিমানা ফলে সঙ্গে হন, তাহলে dequeবস্তু, আপনি সহজেই এটি রূপান্তর করতে পারেন list, setযাই হোক না কেন আপনার মত (উদাহরণস্বরূপ list(lower))। রূপান্তরটি আরও দ্রুত, সরাসরি তালিকাগুলির নির্মাণ।

এই পদ্ধতিগুলি আইটেমের ক্রম পাশাপাশি কোনও নকল রাখে।

Answer 16

উদাহরণস্বরূপ, সমান এবং বিজোড় দ্বারা বিভাজন তালিকা

arr = range(20)
even, odd = reduce(lambda res, next: res[next % 2].append(next) or res, arr, ([], []))

বা সাধারণভাবে:

def split(predicate, iterable):
    return reduce(lambda res, e: res[predicate(e)].append(e) or res, iterable, ([], []))

সুবিধাদি:

• সবচেয়ে স্বল্পতম উপায়
• ভবিষ্যদ্বাণী প্রতিটি উপাদানের জন্য একবার প্রযোজ্য

অসুবিধেও

• ক্রিয়ামূলক প্রোগ্রামিং দৃষ্টান্তের জ্ঞান প্রয়োজন

Answer 17

@ গ্নিবলারের দুর্দান্ত (তবে সংশ্লেষ !) উত্তরে অনুপ্রাণিত হয়ে আমরা একাধিক পার্টিশনে মানচিত্রের জন্য এই পদ্ধতির প্রয়োগ করতে পারি:

from collections import defaultdict

def splitter(l, mapper):
    """Split an iterable into multiple partitions generated by a callable mapper."""

    results = defaultdict(list)

    for x in l:
        results[mapper(x)] += [x]

    return results

এরপরে splitterনিম্নরূপ হিসাবে ব্যবহার করা যেতে পারে:

>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter(l, lambda x: x % 2 == 0)  # partition l into odds and evens
>>> split.items()
>>> [(False, [1, 3, 3, 5, 3, 3]), (True, [2, 4, 2, 4, 6, 4, 2])]

এটি আরও জটিল ম্যাপিং (এবং পুনরাবৃত্তকারীগুলিতেও) সহ আরও দুটি পার্টিশনের জন্য কাজ করে:

>>> import math
>>> l = xrange(1, 23)
>>> split = splitter(l, lambda x: int(math.log10(x) * 5))
>>> split.items()
[(0, [1]),
 (1, [2]),
 (2, [3]),
 (3, [4, 5, 6]),
 (4, [7, 8, 9]),
 (5, [10, 11, 12, 13, 14, 15]),
 (6, [16, 17, 18, 19, 20, 21, 22])]

অথবা মানচিত্রের জন্য একটি অভিধান ব্যবহার করে:

>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter(l, map.get)
>>> split.items()
(1, ['A', 'Y', 'A']), (2, ['C', 'C', 'X']), (3, ['B', 'Z', 'Z'])]

Comments

... কেবলমাত্র লক্ষ্য করা গেছে যে এটি @ অ্যালান-ইসাক ইতিমধ্যে উত্তর দিয়েছে ঠিক তেমন।

— জোশ বোদে

Answer 18

bad = []
good = [x for x in mylist if x in goodvals or bad.append(x)]

পরিবেশন কিছুই দেয় না, তাই এটি কার্যকর।

Answer 19

পারফোলেন্সের জন্য, চেষ্টা করুন itertools।

Itertools মডিউল ফাস্ট একটি মূল সেট, মেমরি দক্ষ সরঞ্জামগুলি আমাদের কাছে নিজেরাই বা একযোগে দরকারী standardizes। একসাথে, তারা একটি "পুনরাবৃত্ত বীজগণিত" গঠন করে যাতে বিশুদ্ধ পাইথনটিতে সংক্ষিপ্তভাবে এবং দক্ষতার সাথে বিশেষ সরঞ্জামগুলি তৈরি করা সম্ভব হয় possible

Itertools.ifilter বা ইম্যাপ দেখুন ।

itertools.ifilter (পূর্বাভাস, পুনরাবৃত্ত)

এমন একটি পুনরুক্তি তৈরি করুন যা কেবল পুনরাবৃত্তিযোগ্য উপাদানগুলির জন্য ফিল্টার করে যা কেবলমাত্র প্রিডিকেট সত্য

Comments

ifilter / imap (এবং সাধারণভাবে জেনারেটর) বেশ ধীর ... সাধারণভাবে, আমার প্রোফাইলিংয়ে, আপনি যদি [x for x in a if x > 50000]100000 পূর্ণসংখ্যার (এলোমেলো.স্যাফেলের মাধ্যমে) একটি সাধারণ অ্যারের মতো একটি তালিকা বোধগম্যতা নেন তবে filter(lambda x: x> 50000, a)2x ifilter(lambda x: x> 50000, a); list(result)সময় লাগবে, লাগে প্রায় 2.3x হিসাবে দীর্ঘ। অদ্ভুত কিন্তু সত্য.

— করলি ব্রিগম্যান

Answer 20

কখনও কখনও আপনার তালিকার অন্য অর্ধেকের প্রয়োজন হবে না। উদাহরণ স্বরূপ:

import sys
from itertools import ifilter

trustedPeople = sys.argv[1].split(',')
newName = sys.argv[2]

myFriends = ifilter(lambda x: x.startswith('Shi'), trustedPeople)

print '%s is %smy friend.' % (newName, newName not in myFriends 'not ' or '')

Answer 21

এটি সবচেয়ে দ্রুততম উপায়।

এটি ব্যবহার করে if else, (ডিবিআরের উত্তরের মতো) তবে প্রথমে একটি সেট তৈরি করে। একটি সেট ও (এম * এন) থেকে ও (লগ এম) + ও (এন) এর ক্রিয়াকলাপ হ্রাস করে, যার ফলে গতি 45% + বৃদ্ধি হয়।

good_list_set = set(good_list)  # 45% faster than a tuple.

good, bad = [], []
for item in my_origin_list:
    if item in good_list_set:
        good.append(item)
    else:
        bad.append(item)

একটু খাটো:

good_list_set = set(good_list)  # 45% faster than a tuple.

good, bad = [], []
for item in my_origin_list:
    out = good if item in good_list_set else bad
    out.append(item)

বেঞ্চমার্ক ফলাফল:

filter_BJHomer                  80/s       --   -3265%   -5312%   -5900%   -6262%   -7273%   -7363%   -8051%   -8162%   -8244%
zip_Funky                       118/s    4848%       --   -3040%   -3913%   -4450%   -5951%   -6085%   -7106%   -7271%   -7393%
two_lst_tuple_JohnLaRoy         170/s   11332%    4367%       --   -1254%   -2026%   -4182%   -4375%   -5842%   -6079%   -6254%
if_else_DBR                     195/s   14392%    6428%    1434%       --    -882%   -3348%   -3568%   -5246%   -5516%   -5717%
two_lst_compr_Parand            213/s   16750%    8016%    2540%     967%       --   -2705%   -2946%   -4786%   -5083%   -5303%
if_else_1_line_DanSalmo         292/s   26668%   14696%    7189%    5033%    3707%       --    -331%   -2853%   -3260%   -3562%
tuple_if_else                   302/s   27923%   15542%    7778%    5548%    4177%     343%       --   -2609%   -3029%   -3341%
set_1_line                      409/s   41308%   24556%   14053%   11035%    9181%    3993%    3529%       --    -569%    -991%
set_shorter                     434/s   44401%   26640%   15503%   12303%   10337%    4836%    4345%     603%       --    -448%
set_if_else                     454/s   46952%   28358%   16699%   13349%   11290%    5532%    5018%    1100%     469%       --

পাইথন ৩.7 এর পূর্ণ মানদণ্ড কোড (ফানকিসায়ু থেকে সংশোধিত):

good_list = ['.jpg','.jpeg','.gif','.bmp','.png']

import random
import string
my_origin_list = []
for i in range(10000):
    fname = ''.join(random.choice(string.ascii_lowercase) for i in range(random.randrange(10)))
    if random.getrandbits(1):
        fext = random.choice(list(good_list))
    else:
        fext = "." + ''.join(random.choice(string.ascii_lowercase) for i in range(3))

    my_origin_list.append((fname + fext, random.randrange(1000), fext))

# Parand
def two_lst_compr_Parand(*_):
    return [e for e in my_origin_list if e[2] in good_list], [e for e in my_origin_list if not e[2] in good_list]

# dbr
def if_else_DBR(*_):
    a, b = list(), list()
    for e in my_origin_list:
        if e[2] in good_list:
            a.append(e)
        else:
            b.append(e)
    return a, b

# John La Rooy
def two_lst_tuple_JohnLaRoy(*_):
    a, b = list(), list()
    for e in my_origin_list:
        (b, a)[e[2] in good_list].append(e)
    return a, b

# # Ants Aasma
# def f4():
#     l1, l2 = tee((e[2] in good_list, e) for e in my_origin_list)
#     return [i for p, i in l1 if p], [i for p, i in l2 if not p]

# My personal way to do
def zip_Funky(*_):
    a, b = zip(*[(e, None) if e[2] in good_list else (None, e) for e in my_origin_list])
    return list(filter(None, a)), list(filter(None, b))

# BJ Homer
def filter_BJHomer(*_):
    return list(filter(lambda e: e[2] in good_list, my_origin_list)), list(filter(lambda e: not e[2] in good_list,                                                                             my_origin_list))

# ChaimG's answer; as a list.
def if_else_1_line_DanSalmo(*_):
    good, bad = [], []
    for e in my_origin_list:
        _ = good.append(e) if e[2] in good_list else bad.append(e)
    return good, bad

# ChaimG's answer; as a set.
def set_1_line(*_):
    good_list_set = set(good_list)
    good, bad = [], []
    for e in my_origin_list:
        _ = good.append(e) if e[2] in good_list_set else bad.append(e)
    return good, bad

# ChaimG set and if else list.
def set_shorter(*_):
    good_list_set = set(good_list)
    good, bad = [], []
    for e in my_origin_list:
        out = good if e[2] in good_list_set else bad
        out.append(e)
    return good, bad

# ChaimG's best answer; if else as a set.
def set_if_else(*_):
    good_list_set = set(good_list)
    good, bad = [], []
    for e in my_origin_list:
        if e[2] in good_list_set:
            good.append(e)
        else:
            bad.append(e)
    return good, bad

# ChaimG's best answer; if else as a set.
def tuple_if_else(*_):
    good_list_tuple = tuple(good_list)
    good, bad = [], []
    for e in my_origin_list:
        if e[2] in good_list_tuple:
            good.append(e)
        else:
            bad.append(e)
    return good, bad

def cmpthese(n=0, functions=None):
    results = {}
    for func_name in functions:
        args = ['%s(range(256))' % func_name, 'from __main__ import %s' % func_name]
        t = Timer(*args)
        results[func_name] = 1 / (t.timeit(number=n) / n) # passes/sec

    functions_sorted = sorted(functions, key=results.__getitem__)
    for f in functions_sorted:
        diff = []
        for func in functions_sorted:
            if func == f:
                diff.append("--")
            else:
                diff.append(f"{results[f]/results[func]*100 - 100:5.0%}")
        diffs = " ".join(f'{x:>8s}' for x in diff)

        print(f"{f:27s} \t{results[f]:,.0f}/s {diffs}")


if __name__=='__main__':
    from timeit import Timer
cmpthese(1000, 'two_lst_compr_Parand if_else_DBR two_lst_tuple_JohnLaRoy zip_Funky filter_BJHomer if_else_1_line_DanSalmo set_1_line set_if_else tuple_if_else set_shorter'.split(" "))

Answer 22

আপনি যদি চালাকের প্রতি জেদ করেন তবে আপনি উইন্ডেনের সমাধান এবং কিছুটা বুদ্ধিমান চালাকি করতে পারেন:

def splay(l, f, d=None):
  d = d or {}
  for x in l: d.setdefault(f(x), []).append(x)
  return d

Comments

"ডি বা {}" কিছুটা বিপজ্জনক। যদি একটি খালি ডিক পাস হয়, এটি জায়গায় পরিবর্তিত হবে না।

— ব্রায়ান

সত্য, তবে এটি ফিরে পেয়েছে, সুতরাং ... আসলে, আপনি নিজের কোডে আরও চালাক কেন যুক্ত করতে চান না তার এটি নিখুঁত উদাহরণ । :

— পি

Answer 23

ইতিমধ্যে এখানে বেশ কয়েকটি সমাধান, তবে এটি করার আরও একটি উপায় হ'ল -

anims = []
images = [f for f in files if (lambda t: True if f[2].lower() in IMAGE_TYPES else anims.append(t) and False)(f)]

তালিকার উপরে একবারে ইটারেটস করা হয় এবং এটি কিছুটা বেশি পাইথোনিক দেখায় এবং তাই আমার কাছে পঠনযোগ্য।

>>> files = [ ('file1.jpg', 33L, '.jpg'), ('file2.avi', 999L, '.avi'), ('file1.bmp', 33L, '.bmp')]
>>> IMAGE_TYPES = ('.jpg','.jpeg','.gif','.bmp','.png')
>>> anims = []
>>> images = [f for f in files if (lambda t: True if f[2].lower() in IMAGE_TYPES else anims.append(t) and False)(f)]
>>> print '\n'.join([str(anims), str(images)])
[('file2.avi', 999L, '.avi')]
[('file1.jpg', 33L, '.jpg'), ('file1.bmp', 33L, '.bmp')]
>>>

Answer 24

তালিকাটিকে ফিল্টারিং থেকে প্রিডিকেটের মূল্যায়ন পৃথক করে আমি ২-পাসের পদ্ধতি গ্রহণ করব:

def partition(pred, iterable):
    xs = list(zip(map(pred, iterable), iterable))
    return [x[1] for x in xs if x[0]], [x[1] for x in xs if not x[0]]

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

এক্সপ্রেটিভিটি-ভিত্তিতে, এটি উপলব্ধি এবং ম্যাপিংয়ের মতো অভিব্যক্তিপূর্ণ আইডিয়ামগুলির সুবিধা গ্রহণ করে।

Answer 25

সমাধান

from itertools import tee

def unpack_args(fn):
    return lambda t: fn(*t)

def separate(fn, lx):
    return map(
        unpack_args(
            lambda i, ly: filter(
                lambda el: bool(i) == fn(el),
                ly)),
        enumerate(tee(lx, 2)))

পরীক্ষা

[even, odd] = separate(
    lambda x: bool(x % 2),
    [1, 2, 3, 4, 5])
print(list(even) == [2, 4])
print(list(odd) == [1, 3, 5])

Answer 26

যদি আপনি সেখানে দুটি বাহ্যিক গ্রন্থাগার ব্যবহার করতে আপত্তি করেন না তবে আমি জানি যে এই অপারেশনটি কার্যকরভাবে কার্যকর করে:

>>> files = [ ('file1.jpg', 33, '.jpg'), ('file2.avi', 999, '.avi')]
>>> IMAGE_TYPES = ('.jpg','.jpeg','.gif','.bmp','.png')

• iteration_utilities.partition:

  >>> from iteration_utilities import partition
  >>> notimages, images = partition(files, lambda x: x[2].lower() in IMAGE_TYPES)
  >>> notimages
  [('file2.avi', 999, '.avi')]
  >>> images
  [('file1.jpg', 33, '.jpg')]

• more_itertools.partition

  >>> from more_itertools import partition
  >>> notimages, images = partition(lambda x: x[2].lower() in IMAGE_TYPES, files)
  >>> list(notimages)  # returns a generator so you need to explicitly convert to list.
  [('file2.avi', 999, '.avi')]
  >>> list(images)
  [('file1.jpg', 33, '.jpg')]

Answer 27

নিশ্চিত না যে এটি একটি ভাল পদ্ধতির কিনা তবে এটি এই পদ্ধতিতেও করা যেতে পারে

IMAGE_TYPES = ('.jpg','.jpeg','.gif','.bmp','.png')
files = [ ('file1.jpg', 33L, '.jpg'), ('file2.avi', 999L, '.avi')]
images, anims = reduce(lambda (i, a), f: (i + [f], a) if f[2] in IMAGE_TYPES else (i, a + [f]), files, ([], []))

Answer 28

তালিকাটি গোষ্ঠী এবং অন্তর্বর্তী বিভাজক দ্বারা তৈরি করা হয়, আপনি ব্যবহার করতে পারেন:

def split(items, p):
    groups = [[]]
    for i in items:
        if p(i):
            groups.append([])
        groups[-1].append(i)
    return groups

ব্যবহার:

split(range(1,11), lambda x: x % 3 == 0)
# gives [[1, 2], [3, 4, 5], [6, 7, 8], [9, 10]]

Answer 29

images = [f for f in files if f[2].lower() in IMAGE_TYPES]
anims  = [f for f in files if f not in images]

যখন অবস্থাটি দীর্ঘতর হয়, যেমন আপনার উদাহরণ হিসাবে ভাল। পাঠককে নেতিবাচক অবস্থাটি নির্ধারণ করতে হবে না এবং এটি অন্যান্য সমস্ত ক্ষেত্রে ক্যাপচার করে কিনা তাও জানার দরকার নেই।

Answer 30

তবুও আরেকটি উত্তর, সংক্ষিপ্ত তবে "অশুভ" (তালিকা-বোঝার পার্শ্ব প্রতিক্রিয়াগুলির জন্য)।

digits = list(range(10))
odd = [x.pop(i) for i, x in enumerate(digits) if x % 2]

>>> odd
[1, 3, 5, 7, 9]

>>> digits
[0, 2, 4, 6, 8]