क्या यह आप कैसे पेजिंग करते हैं, या कोई बेहतर एल्गोरिदम है?

Question

मैं अनुक्रम लेने में सक्षम होना चाहता हूं:

my_sequence = ['foo', 'bar', 'baz', 'spam', 'eggs', 'cheese', 'yogurt'] 

फ़ंक्शन का उपयोग करें:

my_paginated_sequence = get_rows(my_sequence, 3) 

प्राप्त करने के लिए:

[['foo', 'bar', 'baz'], ['spam', 'eggs', 'cheese'], ['yogurt']] 

यही वह है जो मैं बस के साथ आया था इसके माध्यम से सोच रहा है:

def get_rows(sequence, num): 
    count = 1 
    rows = list() 
    cols = list() 
    for item in sequence: 
     if count == num: 
      cols.append(item) 
      rows.append(cols) 
      cols = list() 
      count = 1 
     else: 
      cols.append(item) 
      count += 1 
    if count > 0: 
     rows.append(cols) 
    return rows 

Answer 1

क्या आप जानते हैं कि आप एक sliceable अनुक्रम (सूची या टपल) है, तो

def getrows_byslice(seq, rowlen): 
    for start in xrange(0, len(seq), rowlen): 
     yield seq[start:start+rowlen] 

निश्चित रूप से यह वह जगह है

एक जनरेटर, इसलिए यदि आप पूरी तरह से परिणाम के रूप में एक सूची की जरूरत है, तो आप list(getrows_byslice(seq, 3)) या की तरह, निश्चित रूप से इस्तेमाल करेंगे।

क्या आप के साथ शुरू करते हैं तो एक सामान्य iterable, grouper नुस्खा के साथ itertools recipes प्रस्ताव मदद है ...:

import itertools 

def grouper(n, iterable, fillvalue=None): 
    "grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx" 
    args = [iter(iterable)] * n 
    return itertools.izip_longest(fillvalue=fillvalue, *args) 

(फिर से, तो आप इस पर list कॉल करने के लिए की आवश्यकता होगी, तो एक सूची क्या है आप निश्चित रूप से चाहते हैं)।

के बाद से आप वास्तव में पिछले टपल के बजाय छोटा किया जा तक भरा चाहते हैं, आप बहुत पिछले टपल से "ट्रिम" को पीछे भरने के मूल्यों की आवश्यकता होगी।

Answer 2

आप देख रहे हैं सीधे ऊपर सूची समझ के लिए, यह काम करेगा:

L = ['foo', 'bar', 'baz', 'spam', 'eggs', 'cheese', 'yogurt'] 
[L[i*3 : (i*3)+3] for i in range((len(L)/3)+1) if L[i*3 : (i*3)+3]] 
# [['foo', 'bar', 'baz'], ['spam', 'eggs', 'cheese'], ['yogurt']] 
L = ['foo', 'bar', 'baz', 'spam', 'eggs', 'cheese'] 
# [['foo', 'bar', 'baz'], ['spam', 'eggs', 'cheese']] 

Answer 3

इस संस्करण में किसी भी (संभवतः आलसी और गैर sliceable) iterable साथ काम करता है और एक आलसी iterable पैदा करता है (दूसरे शब्दों में, यह एक जनरेटर है और अन्य जनरेटर सहित दृश्यों के सभी प्रकार, के साथ काम करता है):

import itertools 

def paginate(iterable, page_size): 
    while True: 
     i1, i2 = itertools.tee(iterable) 
     iterable, page = (itertools.islice(i1, page_size, None), 
       list(itertools.islice(i2, page_size))) 
     if len(page) == 0: 
      break 
     yield page 

कुछ उदाहरण:

In [61]: list(paginate(my_sequence, 3)) 
Out[61]: [['foo', 'bar', 'baz'], ['spam', 'eggs', 'cheese'], ['yogurt']] 

In [62]: list(paginate(xrange(10), 3)) 
Out[62]: [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]] 

Answer 4

itertools डॉक्स में grouper समारोह चालाक और संक्षिप्त है, एकमात्र समस्या यह है कि आपको परिणामों को ट्रिम करने की आवश्यकता हो सकती है, क्योंकि एलेक्स मार्टेलि ने बताया। मैं मीकल Marczyk के जवाब की तर्ज पर एक समाधान की ओर झुका हो सकता है, हालांकि मैं नहीं दिख रहा है क्यों कि बहुत सरल नहीं बनाया जा सकता। यह उन सभी मामलों के लिए काम करता है जिनकी मैं कल्पना कर सकता हूं:

import itertools 

def paginate(seq, page_size): 
    i = iter(seq) 
    while True: 
     page = tuple(itertools.islice(i, 0, page_size)) 
     if len(page): 
      yield page 
     else: 
      return