Вопросы Теги

Как распечатать новую строку при достижении определенной точки в цикле? [Дубликат]

Если вы используете Backbone , вы можете получить полнофункциональную функцию перечисления (найти по id, name, custom members) бесплатно, используя Backbone.Collection . 

// enum instance members, optional
var Color = Backbone.Model.extend({
    print : function() {
        console.log("I am " + this.get("name"))
    }
});

// enum creation
var Colors = new Backbone.Collection([
    { id : 1, name : "Red", rgb : 0xFF0000},
    { id : 2, name : "Green" , rgb : 0x00FF00},
    { id : 3, name : "Blue" , rgb : 0x0000FF}
], {
    model : Color
});

// Expose members through public fields.
Colors.each(function(color) {
    Colors[color.get("name")] = color;
});

// using
Colors.Red.print()

2
задан Kassandra 1 December 2012 в 04:06
поделиться

4 ответа

1) 

li = ['sea','mountain','desert',
      'Emma','Cathy','Kate',
      'ii','uuuuuuuuuuuuuuuuuuu','aaa',
      'round','flat','sharp',
      'blueberry','banana','apple',
      'red','purple','white',
      'hen','tiger']

a,b = divmod(len(li),3)
itn = iter(li).next
print ''.join('%s\t%s\t%s\n' % (itn(),itn(),itn())
              for i in xrange(a))\
      + ('%s\t%s\t\n' % (itn(),itn()) if b==2
         else '%s\t\n' % itn() if b==1
         else '')

result 

sea mountain    desert
Emma    Cathy   Kate
ii  uuuuuuuuuuuuuuuuuuu aaa
round   flat    sharp
blueberry   banana  apple
red purple  white
hen tiger

.

2)

И выровнять в столбцах, ширина которых зависит от самого длинного элемента списка: 

li = ['sea','mountain','desert',
      'Emma','Cathy','Kate',
      'HH','VVVVVVV','AAA',
      'round','flat','sharp',
      'blueberry','banana','apple',
      'red','purple','white',
      'hen','tiger']

maxel = max(len(el) for el in li)
a,b = divmod(len(li),3)
itn = iter(li).next
form = '%%-%ds\t%%-%ds\t%%-%ds\n' % (maxel,maxel,maxel)
print ''.join(form % (itn(),itn(),itn())
              for i in xrange(a))\
      + ('%%-%ds\t%%-%ds\t\n' %(maxel,maxel) % (itn(),itn()) if b==2
         else '%%-%ds\t\n' % ma% itn() if b==1
         else '')

result 

sea         mountain    desert   
Emma        Cathy       Kate     
HH          VVVVVVV     AAA      
round       flat        sharp    
blueberry   banana      apple    
red         purple      white    
hen         tiger

.

3)

Чтобы выровнять по столбцу, ширина каждого столбца зависит от самого длинного элемента в нем: 

li = ['sea','mountain','desert',
      'Emma','Cathy','Kate',
      'HH','VVVVVVV','AAA',
      'round','flat','sharp',
      'nut','banana','apple',
      'red','purple','white',
      'hen','tiger']

maxel0 = max(len(li[i]) for i in xrange(0,len(li),3)) 
maxel1 = max(len(li[i]) for i in xrange(1,len(li),3))
maxel2 = max(len(li[i]) for i in xrange(2,len(li),3))
a,b = divmod(len(li),3)
itn = iter(li).next
form = '%%-%ds\t%%-%ds\t%%-%ds\n' % (maxel0,maxel1,maxel2)
print ''.join(form % (itn(),itn(),itn())
              for i in xrange(a))\
      + ('%%-%ds\t%%-%ds\t\n' %(maxel0,maxel1) % (itn(),itn()) if b==2
         else '%%-%ds\t\n' % maxel0 % itn() if b==1
         else '')

result 

sea     mountain    desert
Emma    Cathy       Kate  
HH      VVVVVVV     AAA   
round   flat        sharp 
nut     banana      apple 
red     purple      white 
hen     tiger

4)

Я модифицировал алгоритм для обобщения на любое количество желаемых столбцов. Требуемое количество столбцов должно быть передано в качестве аргумента в параметр nc: 

from itertools import imap,islice

li = ['sea','mountain','desert',
      'Emma','Cathy','Kate',
      'HH','VVVVVVV','AAA',
      'round','flat','sharp',
      'nut','banana','apple',
      'heeeeeeeeeeen','tiger','snake'
      'red','purple','white',
      'atlantic','pacific','antarctic',
      'Bellini']

print 'len of li == %d\n' % len(li)

def cols_print(li,nc):
    maxel = tuple(max(imap(len,islice(li,st,None,nc)))
                  for st in xrange(nc))

    nblines,tail = divmod(len(li),nc)
    stakes = (nc-1)*['%%-%ds\t'] + ['%%-%ds']
    form = ''.join(stakes) % maxel

    itn = iter(li).next

    print '\n'.join(form % tuple(itn() for g in xrange(nc))
                  for i in xrange(nblines)) 
    if tail:
        print ''.join(stakes[nc-tail:]) % maxel[0:tail] % tuple(li[-tail:]) + '\n'
    else:
        print


for nc in xrange(3,8):
    cols_print(li,nc)
    print '-----------------------------------------------------------'

result 

len of li == 24

sea             mountain    desert  
Emma            Cathy       Kate    
HH              VVVVVVV     AAA     
round           flat        sharp   
nut             banana      apple   
heeeeeeeeeeen   tiger       snakered
purple          white       atlantic
pacific         antarctic   Bellini 

-----------------------------------------------------------
sea         mountain    desert      Emma         
Cathy       Kate        HH          VVVVVVV      
AAA         round       flat        sharp        
nut         banana      apple       heeeeeeeeeeen
tiger       snakered    purple      white        
atlantic    pacific     antarctic   Bellini      

-----------------------------------------------------------
sea             mountain    desert      Emma    Cathy
Kate            HH          VVVVVVV     AAA     round
flat            sharp       nut         banana  apple
heeeeeeeeeeen   tiger       snakered    purple  white
atlantic        pacific     antarctic   Bellini

-----------------------------------------------------------
sea     mountain    desert      Emma            Cathy       Kate    
HH      VVVVVVV     AAA         round           flat        sharp   
nut     banana      apple       heeeeeeeeeeen   tiger       snakered
purple  white       atlantic    pacific         antarctic   Bellini 

-----------------------------------------------------------
sea     mountain        desert  Emma        Cathy   Kate    HH      
VVVVVVV AAA             round   flat        sharp   nut     banana  
apple   heeeeeeeeeeen   tiger   snakered    purple  white   atlantic
pacific antarctic       Bellini

-----------------------------------------------------------

.

Но я предпочитаю отображение, в котором нет столбцов между столбцами, но только определенное количество символов. В следующем коде я решил выделить столбцы на 2 символа: это 2 в строке 

maxel = tuple(max(imap(len,islice(li,st,None,nc)))+2

Код 

from itertools import imap,islice

li = ['sea','mountain','desert',
      'Emma','Cathy','Kate',
      'HH','VVVVVVV','AAA',
      'round','flat','sharp',
      'nut','banana','apple',
      'heeeeeeeeeeen','tiger','snake'
      'red','purple','white',
      'atlantic','pacific','antarctic',
      'Bellini']

print 'len of li == %d\n' % len(li)
def cols_print(li,nc):
    maxel = tuple(max(imap(len,islice(li,st,None,nc)))+2
                  for st in xrange(nc))

    nblines,tail = divmod(len(li),nc)
    stakes = nc*['%%-%ds']
    form = ''.join(stakes) % maxel

    itn = iter(li).next

    print '\n'.join(form % tuple(itn() for g in xrange(nc))
                  for i in xrange(nblines)) 
    if tail:
        print ''.join(stakes[nc-tail:]) % maxel[0:tail] % tuple(li[-tail:]) + '\n'
    else:
        print


for nc in xrange(3,8):
    cols_print(li,nc)
    print 'mwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwm'

Результат 

len of li == 24

sea            mountain   desert    
Emma           Cathy      Kate      
HH             VVVVVVV    AAA       
round          flat       sharp     
nut            banana     apple     
heeeeeeeeeeen  tiger      snakered  
purple         white      atlantic  
pacific        antarctic  Bellini   

mwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwm
sea       mountain  desert     Emma           
Cathy     Kate      HH         VVVVVVV        
AAA       round     flat       sharp          
nut       banana    apple      heeeeeeeeeeen  
tiger     snakered  purple     white          
atlantic  pacific   antarctic  Bellini        

mwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwm
sea            mountain  desert     Emma     Cathy  
Kate           HH        VVVVVVV    AAA      round  
flat           sharp     nut        banana   apple  
heeeeeeeeeeen  tiger     snakered   purple   white  
atlantic       pacific   antarctic  Bellini  

mwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwm
sea     mountain  desert    Emma           Cathy      Kate      
HH      VVVVVVV   AAA       round          flat       sharp     
nut     banana    apple     heeeeeeeeeeen  tiger      snakered  
purple  white     atlantic  pacific        antarctic  Bellini   

mwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwm
sea      mountain       desert   Emma      Cathy   Kate   HH        
VVVVVVV  AAA            round    flat      sharp   nut    banana    
apple    heeeeeeeeeeen  tiger    snakered  purple  white  atlantic  
pacific  antarctic      Bellini  

mwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwmwm
4
ответ дан eyquem 25 August 2018 в 09:08
поделиться

Вы также можете попробовать следующее: 

from itertools import izip

l = ['name1', 'name2', 'name3', 'name4', 'name5', 'name6']

for t in izip(*[iter(l)]*3):
    print '\t'.join(t)

name1   name2   name3
name4   name5   name6

Если вы не уверены, что длина списка будет кратной 3, вы можете использовать izip_longest, применяя та же идея: 

from itertools import izip_longest as izipl

l = ['name1', 'name2', 'name3', 'name4', 'name5', 'name6', 'name7']

for t in izipl(fillvalue='', *[iter(l)]*3):
    print '\t'.join(t)

name1   name2   name3
name4   name5   name6
name7
2
ответ дан arshajii 25 August 2018 в 09:08
поделиться

Попробуйте использовать itertools, я думаю, что это гораздо более простое решение. 

from itertools import izip_longest

def grouper(n, iterable, fillvalue=None):
    args = [iter(iterable)] * n
    return izip_longest(fillvalue=fillvalue, *args)

names = ['name1', 'name2', 'name3', 'name4', 'name5', 'name6']
for item1 in grouper(3, names, ''):
    print '\t'.join(item1)

Результат: 

name1   name2   name3
name4   name5   name6
1
ответ дан enginefree 25 August 2018 в 09:08
поделиться

Это должно сделать это: 

In [12]: L
Out[12]: ['name1', 'name2', 'name3', 'name4', 'name5', 'name6']

In [13]: for i in range(0,len(L),3): print ' '.join(L[i:i+3])
name1 name2 name3
name4 name5 name6

EDIT: получить все в фиксированную ширину (некоторый код, который я написал некоторое время, чтобы превратить столбчатые данные в таблицу. Все, что вам нужно сделать, это columnize ваши данные и вызов этого старого кода): 

def tabularize(infilepath, outfilepath, delim='\t', largeFile=False):
        """ Return nothing
                Write into the file in outfilepath, the contents of infilepath, expressed in tabular form.
                The tabular form is similar to the way in which SQL tables are displayed.
                If largeFile is set to True, then no caching of lines occurs. However, two passes of the infile are required"""

        if largeFile:
                widths = getWidths(infilepath, delim)
        else:
                with open(infilepath) as infile:
                        lines = [line.strip().split(delim) for line in infile.readlines() if line.strip()]
                widths = [max([len(row) for row in rows])+2 for rows in izip_longest(*lines, fillvalue="")]

                with open(outfilepath, 'w') as outfile:
                        outfile.write("+")
                        for width in widths:
                                outfile.write('-'*width + "+")
                        outfile.write('\n')
                        for line in lines:
                                outfile.write("|")
                                for col,width in izip_longest(line,widths, fillvalue=""):
                                        outfile.write("%s%s%s|" %(' '*((width-len(col))/2), col, ' '*((width+1-len(col))/2)))
                                outfile.write('\n+')
                                for width in widths:
                                        outfile.write('-'*width + "+")
                                outfile.write('\n')

def getWidths(infilepath, delim):
        answer = defaultdict(int)
        with open(infilepath) as infile:
                for line in infile:
                        cols = line.strip().split(delim)
                        lens = map(len, cols)
                        for i,l in enumerate(lens):
                                if answer[i] < l:
                                        answer[i] = l

        return [answer[k] for k in sorted(answer)]

def main(L, n, infilepath, outfilepath):
    iterator = iter(L)
    with open(infilepath, 'w') as infile:
        for row in itertools.izip_longest([iterator]*n, fillavalue=''):
            infile.write('\t'.join(row)+'\n')
    if len(L) > 10**6:
        largeFile = True
    tabularize(infilepath, outfilepath, delim='\t', largeFile)
2
ответ дан inspectorG4dget 25 August 2018 в 09:08
поделиться
Другие вопросы по тегам:

Похожие вопросы: