python tutorial टैब्यूलर डेटा के रूप में प्रिंटिंग सूचियां




python tutorial (8)

मैं पाइथन के लिए काफी नया हूं और अब मैं मुद्रित आउटपुट के लिए अपने डेटा को अच्छी तरह से स्वरूपित करने के साथ संघर्ष कर रहा हूं।

मेरे पास एक सूची है जिसका उपयोग दो शीर्षकों के लिए किया जाता है, और एक मैट्रिक्स जो तालिका की सामग्री होनी चाहिए। इस तरह:

teams_list = ["Man Utd", "Man City", "T Hotspur"]
data = np.array([[1, 2, 1],
                 [0, 1, 0],
                 [2, 4, 2]])

ध्यान दें कि शीर्षक नाम जरूरी नहीं हैं। हालांकि डेटा प्रविष्टियां सभी पूर्णांक हैं।

अब, मैं इसे एक टेबल प्रारूप में प्रस्तुत करना चाहता हूं, ऐसा कुछ:

            Man Utd   Man City   T Hotspur
  Man Utd         1          0           0
 Man City         1          1           0
T Hotspur         0          1           2

मेरे पास एक झुकाव है कि इसके लिए एक डेटा संरचना होनी चाहिए, लेकिन मुझे यह नहीं मिल रहा है। मैंने एक शब्दकोश का उपयोग करने और प्रिंटिंग को स्वरूपित करने का प्रयास किया है, मैंने इंडेंटेशन के साथ फॉर-लूप की कोशिश की है और मैंने स्ट्रिंग के रूप में प्रिंट करने का प्रयास किया है।

मुझे यकीन है कि ऐसा करने का एक बहुत ही सरल तरीका होना चाहिए, लेकिन अनुभव की कमी के कारण शायद मुझे यह याद आ रही है।


मैं सूची के माध्यम से लूप करने की कोशिश करता हूं और आपके इच्छित डेटा का प्रतिनिधित्व करने के लिए एक CSV फ़ॉर्मेटर का उपयोग करता हूं।

आप टैब, कॉमा या किसी अन्य चार को डिलीमीटर के रूप में निर्दिष्ट कर सकते हैं।

अन्यथा, सूची के माध्यम से बस लूप करें और प्रत्येक तत्व के बाद "\ t" प्रिंट करें

http://docs.python.org/library/csv.html


शुद्ध पायथन 3

def print_table(data, cols, wide):
    '''Prints formatted data on columns of given width.'''
    n, r = divmod(len(data), cols)
    pat = '{{:{}}}'.format(wide)
    line = '\n'.join(pat * cols for _ in range(n))
    last_line = pat * r
    print(line.format(*data))
    print(last_line.format(*data[n*cols:]))

data = [str(i) for i in range(27)]
print_table(data, 6, 12)

प्रिंट करेंगे

0           1           2           3           4           5           
6           7           8           9           10          11          
12          13          14          15          16          17          
18          19          20          21          22          23          
24          25          26

इस उद्देश्य के लिए कुछ हल्के और उपयोगी पायथन पैकेज हैं:

1. सारणीबद्ध करें : https://pypi.python.org/pypi/tabulate

>>> from tabulate import tabulate
>>> print tabulate([['Alice', 24], ['Bob', 19]], headers=['Name', 'Age'])
Name      Age
------  -----
Alice      24
Bob        19

टैबलेट में हेडर और टेबल प्रारूप निर्दिष्ट करने के लिए कई विकल्प हैं।

>>> print tabulate([['Alice', 24], ['Bob', 19]], headers=['Name', 'Age'], tablefmt='orgtbl')
| Name   |   Age |
|--------+-------|
| Alice  |    24 |
| Bob    |    19 |

2. PrettyTable : https://pypi.python.org/pypi/PrettyTable

>>> from prettytable import PrettyTable
>>> t = PrettyTable(['Name', 'Age'])
>>> t.add_row(['Alice', 24])
>>> t.add_row(['Bob', 19])
>>> print t
+-------+-----+
|  Name | Age |
+-------+-----+
| Alice |  24 |
|  Bob  |  19 |
+-------+-----+

PrettyTable में सीएसवी, एचटीएमएल, एसक्यूएल डेटाबेस से डेटा पढ़ने के विकल्प हैं। इसके अलावा आप डेटा का सबसेट चुन सकते हैं, टेबल को सॉर्ट कर सकते हैं और तालिका शैलियों को बदल सकते हैं।

3. टेक्स्टटेबल : https://pypi.python.org/pypi/texttable

>>> from texttable import Texttable
>>> t = Texttable()
>>> t.add_rows([['Name', 'Age'], ['Alice', 24], ['Bob', 19]])
>>> print t.draw()
+-------+-----+
| Name  | Age |
+=======+=====+
| Alice | 24  |
+-------+-----+
| Bob   | 19  |
+-------+-----+

टेक्स्टटेबल के साथ आप क्षैतिज / लंबवत संरेखण, सीमा शैली और डेटा प्रकारों को नियंत्रित कर सकते हैं।

अन्य विकल्प:

  • terminaltables आसानी से स्ट्रिंग्स की सूचियों की सूची से टर्मिनल / कंसोल अनुप्रयोगों में तालिकाओं को खींचते हैं। बहु लाइन पंक्तियों का समर्थन करता है।
  • asciitable Asciitable अंतर्निहित विस्तार रीडर कक्षाओं के माध्यम से ASCII तालिका स्वरूपों की एक विस्तृत श्रृंखला को पढ़ और लिख सकते हैं।

https://pypi.python.org/pypi/tabulate और https://pypi.python.org/pypi/tabulate कुछ समस्याएं हैं जिनका उपयोग आप अपनी समस्या को हल करने के लिए कर सकते हैं।

सुंदरता के documentation से यहां एक उदाहरण दिया गया है

>>> from beautifultable import BeautifulTable
>>> table = BeautifulTable()
>>> table.column_headers = ["name", "rank", "gender"]
>>> table.append_row(["Jacob", 1, "boy"])
>>> table.append_row(["Isabella", 1, "girl"])
>>> table.append_row(["Ethan", 2, "boy"])
>>> table.append_row(["Sophia", 2, "girl"])
>>> table.append_row(["Michael", 3, "boy"])
>>> print(table)
+----------+------+--------+
|   name   | rank | gender |
+----------+------+--------+
|  Jacob   |  1   |  boy   |
+----------+------+--------+
| Isabella |  1   |  girl  |
+----------+------+--------+
|  Ethan   |  2   |  boy   |
+----------+------+--------+
|  Sophia  |  2   |  girl  |
+----------+------+--------+
| Michael  |  3   |  boy   |
+----------+------+--------+

पाइथन वास्तव में यह काफी आसान बनाता है।

कुछ इस तरह

for i in range(10):
    print '%-12i%-12i' % (10 ** i, 20 ** i)

आउटपुट होगा

1           1           
10          20          
100         400         
1000        8000        
10000       160000      
100000      3200000     
1000000     64000000    
10000000    1280000000  
100000000   25600000000
1000000000  512000000000

स्ट्रिंग के भीतर% अनिवार्य रूप से एक बचने वाला चरित्र है और इसके बाद के वर्ण पाइथन को बताते हैं कि डेटा के किस प्रकार का स्वरूप होना चाहिए। स्ट्रिंग के बाहर और बाद में% पाइथन कह रहा है कि आप पिछले स्ट्रिंग को प्रारूप स्ट्रिंग के रूप में उपयोग करना चाहते हैं और निर्दिष्ट डेटा निर्दिष्ट प्रारूप में रखा जाना चाहिए।

इस मामले में मैंने दो बार "% -12i" इस्तेमाल किया था। प्रत्येक भाग को तोड़ने के लिए:

'-' (left align)
'12' (how much space to be given to this part of the output)
'i' (we are printing an integer)

दस्तावेज़ों से: https://docs.python.org/2/library/stdtypes.html#string-formatting


जब मैं ऐसा करता हूं, तो मुझे तालिका के स्वरूपित होने के विवरण के बारे में कुछ नियंत्रण रखना पसंद है। विशेष रूप से, मैं हेडर कोशिकाओं को शरीर की कोशिकाओं की तुलना में एक अलग प्रारूप रखना चाहता हूं, और तालिका कॉलम चौड़ाई केवल उतनी चौड़ी होनी चाहिए जितनी प्रत्येक को होना चाहिए। मेरा समाधान यहाँ है:

def format_matrix(header, matrix,
                  top_format, left_format, cell_format, row_delim, col_delim):
    table = [[''] + header] + [[name] + row for name, row in zip(header, matrix)]
    table_format = [['{:^{}}'] + len(header) * [top_format]] \
                 + len(matrix) * [[left_format] + len(header) * [cell_format]]
    col_widths = [max(
                      len(format.format(cell, 0))
                      for format, cell in zip(col_format, col))
                  for col_format, col in zip(zip(*table_format), zip(*table))]
    return row_delim.join(
               col_delim.join(
                   format.format(cell, width)
                   for format, cell, width in zip(row_format, row, col_widths))
               for row_format, row in zip(table_format, table))

print format_matrix(['Man Utd', 'Man City', 'T Hotspur', 'Really Long Column'],
                    [[1, 2, 1, -1], [0, 1, 0, 5], [2, 4, 2, 2], [0, 1, 0, 6]],
                    '{:^{}}', '{:<{}}', '{:>{}.3f}', '\n', ' | ')

आउटपुट यहां है:

                   | Man Utd | Man City | T Hotspur | Really Long Column
Man Utd            |   1.000 |    2.000 |     1.000 |             -1.000
Man City           |   0.000 |    1.000 |     0.000 |              5.000
T Hotspur          |   2.000 |    4.000 |     2.000 |              2.000
Really Long Column |   0.000 |    1.000 |     0.000 |              6.000

मुझे लगता है कि this वही है जो आप खोज रहे हैं।

यह एक साधारण मॉड्यूल है जो तालिका प्रविष्टियों के लिए अधिकतम आवश्यक चौड़ाई की गणना करता है और फिर डेटा का एक सुंदर प्रिंट करने के लिए बस rjust और ljust का उपयोग करता है।

यदि आप चाहते हैं कि आपका बायां शीर्षक सही गठबंधन है तो बस इस कॉल को बदलें:

 print >> out, row[0].ljust(col_paddings[0] + 1),

लाइन 53 से:

 print >> out, row[0].rjust(col_paddings[0] + 1),

>>> import pandas
>>> pandas.DataFrame(data, teams_list, teams_list)
           Man Utd  Man City  T Hotspur
Man Utd    1        2         1        
Man City   0        1         0        
T Hotspur  2        4         2        




python