सारणीबद्ध डेटा के रूप में मुद्रण सूची


366

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

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

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

मेरे पास एक कूबड़ है कि इसके लिए एक डेटा संरचना होनी चाहिए, लेकिन मैं इसे नहीं पा सकता हूं। मैंने एक शब्दकोश का उपयोग करने की कोशिश की है और मुद्रण का प्रारूपण किया है, मैंने इंडेंटेशन के लिए लूप की कोशिश की है और मैंने मुद्रण को स्ट्रिंग्स के रूप में आज़माया है।

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


1
+1, मैं कल रात से यही काम करना चाह रहा था। क्या आप केवल कमांड लाइन पर प्रिंट करने का प्रयास कर रहे हैं या आप GUI मॉड्यूल का उपयोग कर रहे हैं?
हेलामाड

सिर्फ कमांड लाइन पर मुद्रण। हालांकि, इसे एक इकाई-परीक्षण के मामले में पारित करने की आवश्यकता है, इसलिए यहां प्रारूपण बहुत महत्वपूर्ण है।
hjweide



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

जवाबों:


189

पायथन 2.7 के लिए कुछ तदर्थ कोड:

row_format ="{:>15}" * (len(teams_list) + 1)
print(row_format.format("", *teams_list))
for team, row in zip(teams_list, data):
    print(row_format.format(team, *row))

यह str.format()और प्रारूप विनिर्देश मिनी-भाषा पर निर्भर करता है ।


3
अगर python2.6 का उपयोग करना याद रखें row_format पर team_list इंडेक्स जोड़ना: row_format = "{0:> 15} {1:> 15} {2:> 15}"
लुइस म्यूनोज़

1
यदि शरीर में डेटा हेडर से बड़ा है, तो आप डेटा की पहली पंक्ति के आधार पर कॉलम की चौड़ाई निर्धारित कर सकते हैं। डेटा में t के लिए [0]: row_format + = "{: <" + + str (len (t) +5) + "}"
morgantaschuk

587

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

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. सुंदर : 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 में csv, html, sql डेटाबेस से डेटा पढ़ने के विकल्प हैं। इसके अलावा, आप डेटा, सॉर्ट टेबल और परिवर्तन तालिका शैलियों के सबसेट का चयन करने में सक्षम हैं।

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  |
+-------+-----+

टेक्सटेबल के साथ आप क्षैतिज / वर्टिकल अलाइन, बॉर्डर स्टाइल और डेटा प्रकारों को नियंत्रित कर सकते हैं।

4. शब्दावलियाँ : https://github.com/nschloe/termtables

import termtables as tt

string = tt.to_string(
    [["Alice", 24], ["Bob", 19]],
    header=["Name", "Age"],
    style=tt.styles.ascii_thin_double,
    # alignment="ll",
    # padding=(0, 1),
)
print(string)
+-------+-----+
| Name  | Age |
+=======+=====+
| Alice | 24  |
+-------+-----+
| Bob   | 19  |
+-------+-----+

टेक्सटेबल के साथ आप क्षैतिज / वर्टिकल अलाइन, बॉर्डर स्टाइल और डेटा प्रकारों को नियंत्रित कर सकते हैं।

अन्य विकल्प:

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

13
मैंने डेटा-केंद्रित सीएलआई उपकरणों के निर्माण के लिए एक बहुत उपयोगी उपकरण होने के लिए सारणीबद्ध पाया है। वह, क्लिक (पाइप इंस्टॉल क्लिक) के साथ संयुक्त है, और आपको एक वास्तविक स्टू जा रहा है।
एलेक्सबॉव

4
यह अद्भुत है, धन्यवाद। व्यक्तिगत रूप से, आप उन तीनों में से किसे पसंद करेंगे?
जिम रेनोर

शानदार जवाब! प्रिटीटेबल सिर्फ इतना अच्छा है - अन्य दो विकल्पों के बीच सही संतुलन।
०१:०५ पर edesz

2
टर्मिनल चीनी, शायद अन्य गैर-अंग्रेजी भाषाओं के लिए अच्छा है
विचारक

5
मैं सिर्फ मुख्य पैकेज और IMO "ब्यूटिफुलेबल" के साथ खेला - सर्वश्रेष्ठ, बनाए रखा, अच्छा एपीआई और डोको, रंग के लिए समर्थन। "texttable" - अच्छा, बनाए रखा, अच्छा एपीआई लेकिन रंग का उपयोग संरेखण से बाहर तालिकाओं फेंकता है। "टर्मिनलटैबल्स" - केवल कोड उदाहरणों के माध्यम से अच्छा, डोको। "प्रिटीटेबल" - ठीक है, लेकिन पुराना, टेबल 'शीर्षक' मेरे लिए काम नहीं करता है। "Tabulate" - अच्छा है, लेकिन कॉलम संरेखण coalignकीवर्ड आधिकारिक पीपीआई रिलीज में समर्थित नहीं है। "टेबलप्रिंट" - औसत, एपीआई जटिल, पर्याप्त सामान्य उपयोग के उदाहरण नहीं।
अबुलका

79
>>> 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        

6
यह बहुत ही आशाजनक लग रहा है, धन्यवाद, लेकिन मैं पूरी तरह से आवश्यक से अधिक आयातित पुस्तकालयों का उपयोग किए बिना ऐसा करने की कोशिश कर रहा हूं।
hjweide

26
सिर्फ आउटपुट स्वरूपण के लिए पांडा का उपयोग करना ओवरकिल (पूंजी ओ इरादा) की तरह लगता है।
नील्स

66
@ नील्सबॉम: आउटपुट स्वरूपण के लिए आते हैं, डेटा विश्लेषण और मॉडलिंग के लिए बने रहते हैं :)
jfs

30
@JFSebastian मेरे लिए यह अधिक पसंद था "आउटपुट स्वरूपण के लिए आते हैं, 10 मिनट की नुकीली संकलन के कारण चिल्लाते हुए भागते हैं जो मेरे कंप्यूटर को हेअर ड्रायर की तरह आवाज देता है" ;-)
नील्स बॉम्ब

4
@ नील्सबॉम: pip install numpyअब अधिकांश प्लेटफार्मों (कोई संकलन) पर बाइनरी पहियों का उपयोग करता है । जाहिर है, इससे पहले भी अन्य बाइनरी इंस्टॉलेशन विकल्प उपलब्ध थे।
jfs

68

अजगर वास्तव में यह काफी आसान बनाता है।

कुछ इस तरह

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


इस जवाब ने मुझे खोज लिया कि मैं क्या देख रहा था! अजगर 3 के लिए, मैं की तरह इसे का उपयोग समाप्त हो गया print('%-20.2f' % position['deg'], '%-17.2f' % position['v2'])है, जहां .2नाव की निर्दिष्ट परिशुद्धताf
रॉस


9

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

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

8

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

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

यदि आप चाहते हैं कि आपकी बाईं ओर दाईं ओर संरेखित करें तो इस कॉल को बदलें:

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

पंक्ति 53 के साथ:

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

8

मुझे पता है कि मुझे पार्टी में देर हो गई है, लेकिन मैंने इसके लिए सिर्फ एक पुस्तकालय बनाया है जो मुझे लगता है कि वास्तव में मदद कर सकता है। यह बेहद सरल है, इसीलिए मुझे लगता है कि आपको इसका इस्तेमाल करना चाहिए। इसे टेबलिट कहा जाता है ।

मूल उपयोग

इसका उपयोग करने के लिए, पहले GitHub पेज पर डाउनलोड निर्देशों का पालन करें ।

फिर इसे आयात करें:

import TableIt

फिर उन सूचियों की सूची बनाएं जहां प्रत्येक आंतरिक सूची एक पंक्ति है:

table = [
    [4, 3, "Hi"],
    [2, 1, 808890312093],
    [5, "Hi", "Bye"]
]

फिर आपको इसे प्रिंट करना होगा:

TableIt.printTable(table)

यह आपको मिलने वाला आउटपुट है:

+--------------------------------------------+
| 4            | 3            | Hi           |
| 2            | 1            | 808890312093 |
| 5            | Hi           | Bye          |
+--------------------------------------------+

क्षेत्र का नाम

यदि आप चाहते हैं, तो आप फ़ील्ड नामों का उपयोग कर सकते हैं ( यदि आप फ़ील्ड नामों का उपयोग नहीं कर रहे हैं, तो आपको उपयोग करने के लिए कहने की ज़रूरत नहीं है = गलत क्योंकि यह डिफ़ॉल्ट रूप से सेट है ):


TableIt.printTable(table, useFieldNames=True)

उससे आपको मिलेगा:

+--------------------------------------------+
| 4            | 3            | Hi           |
+--------------+--------------+--------------+
| 2            | 1            | 808890312093 |
| 5            | Hi           | Bye          |
+--------------------------------------------+

उदाहरण के लिए, आप ऐसा कर सकते हैं:

import TableIt

myList = [
    ["Name", "Email"],
    ["Richard", "richard@fakeemail.com"],
    ["Tasha", "tash@fakeemail.com"]
]

TableIt.print(myList, useFieldNames=True)

उसमें से:

+-----------------------------------------------+
| Name                  | Email                 |
+-----------------------+-----------------------+
| Richard               | richard@fakeemail.com |
| Tasha                 | tash@fakeemail.com    |
+-----------------------------------------------+

या आप कर सकते हैं:

import TableIt

myList = [
    ["", "a", "b"],
    ["x", "a + x", "a + b"],
    ["z", "a + z", "z + b"]
]

TableIt.printTable(myList, useFieldNames=True)

और इससे आपको मिलता है:

+-----------------------+
|       | a     | b     |
+-------+-------+-------+
| x     | a + x | a + b |
| z     | a + z | z + b |
+-----------------------+

रंग की

आप रंगों का भी उपयोग कर सकते हैं।

आप रंग विकल्प का उपयोग करके रंगों का उपयोग करते हैं ( डिफ़ॉल्ट रूप से यह किसी के लिए सेट नहीं है ) और आरजीबी मूल्यों को निर्दिष्ट करता है।

ऊपर से उदाहरण का उपयोग करना:

import TableIt

myList = [
    ["", "a", "b"],
    ["x", "a + x", "a + b"],
    ["z", "a + z", "z + b"]
]

TableIt.printTable(myList, useFieldNames=True, color=(26, 156, 171))

तब आपको मिलेगा:

यहां छवि विवरण दर्ज करें

कृपया ध्यान दें कि मुद्रण रंग आपके लिए काम नहीं कर सकता है, लेकिन यह अन्य पुस्तकालयों के समान ही काम करता है जो रंगीन पाठ को प्रिंट करते हैं। मैंने परीक्षण किया है और हर एक रंग काम करता है। नीले रंग को गड़बड़ नहीं किया जाता है क्योंकि यह डिफ़ॉल्ट 34mएएनएसआई से बचने के क्रम का उपयोग करेगा (यदि आपको नहीं पता कि यह क्या है तो कोई फर्क नहीं पड़ता)। वैसे भी, यह सब इस तथ्य से आता है कि हर रंग सिस्टम डिफ़ॉल्ट के बजाय आरजीबी मूल्य है।

और जानकारी

अधिक जानकारी के लिए GitHub पेज देखें


TableIt वास्तव में एक अच्छा उपकरण है। सरल लेकिन शक्तिशाली। मेरे विचार से एकमात्र नुकसान यह है कि TableIt ने एक LICENSE घोषित नहीं किया है
Endle_Zhenbo

@Endle_Zhenbo अरे! बहुत बहुत धन्यवाद, मैं जल्द से जल्द उस पर काम करूँगा!
बीस्टकोडर

@Endle_Zhenbo, मुझे पता है कि यह एक समय हो गया है, लेकिन मैंने आखिरकार परियोजना पर एक लाइसेंस रखा।
बीस्टकोडर

7

शुद्ध अजगर ३

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

5

ऐसा करने का एक सरल तरीका यह है कि सभी स्तंभों पर लूप करें, उनकी चौड़ाई को मापें, उस अधिकतम चौड़ाई के लिए एक row_template बनाएं और फिर पंक्तियों को प्रिंट करें। यह ठीक नहीं है कि आप क्या देख रहे हैं , क्योंकि इस मामले में, आपको सबसे पहले अपनी हेडिंग को टेबल के अंदर रखना होगा , लेकिन मैं सोच रहा हूं कि यह किसी और के लिए उपयोगी हो सकता है।

table = [
    ["", "Man Utd", "Man City", "T Hotspur"],
    ["Man Utd", 1, 0, 0],
    ["Man City", 1, 1, 0],
    ["T Hotspur", 0, 1, 2],
]
def print_table(table):
    longest_cols = [
        (max([len(str(row[i])) for row in table]) + 3)
        for i in range(len(table[0]))
    ]
    row_format = "".join(["{:>" + str(longest_col) + "}" for longest_col in longest_cols])
    for row in table:
        print(row_format.format(*row))

आप इसे इस तरह उपयोग करते हैं:

>>> print_table(table)

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

3

निम्नलिखित फ़ंक्शन पायथन 3 (शायद पायथन 2 के साथ) के साथ अनुरोधित तालिका (अंक के साथ या बिना खतना के) बनाएगा। मैंने सबसे लंबे टीम नाम से मेल खाने के लिए प्रत्येक कॉलम की चौड़ाई निर्धारित करने के लिए चुना है। यदि आप प्रत्येक स्तंभ के लिए टीम के नाम की लंबाई का उपयोग करना चाहते हैं, तो आप इसे संशोधित कर सकते हैं, लेकिन यह अधिक जटिल होगा।

नोट: अजगर 2 में एक प्रत्यक्ष समकक्ष के लिए आप बदल सकते zipसाथ izipitertools से।

def print_results_table(data, teams_list):
    str_l = max(len(t) for t in teams_list)
    print(" ".join(['{:>{length}s}'.format(t, length = str_l) for t in [" "] + teams_list]))
    for t, row in zip(teams_list, data):
        print(" ".join(['{:>{length}s}'.format(str(x), length = str_l) for x in [t] + row]))

teams_list = ["Man Utd", "Man City", "T Hotspur"]
data = [[1, 2, 1],
        [0, 1, 0],
        [2, 4, 2]]

print_results_table(data, teams_list)

यह निम्न तालिका का उत्पादन करेगा:

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

आप खड़ी रेखा विभाजक करना चाहते हैं, तो आप बदल सकते हैं " ".joinके साथ " | ".join

संदर्भ:


2

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

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

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

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


यह मेरा प्रारंभिक प्रयास था, यह शायद किया जा सकता है, लेकिन यह स्वरूपण को सही बनाने के लिए बहुत प्रयास लगता है।
15 नवंबर को hjweide

2

मुझे यह सिर्फ साधारण कॉलम आउटपुट के लिए एक रास्ता मिल गया। अगर आपको सिर्फ नो-फ़स कॉलम की आवश्यकता है , तो आप इसका उपयोग कर सकते हैं:

print("Titlex\tTitley\tTitlez")
for x, y, z in data:
    print(x, "\t", y, "\t", z)

संपादित करें: मैं जितना संभव हो उतना सरल होने की कोशिश कर रहा था, और इस प्रकार टीमों की सूची का उपयोग करने के बजाय मैन्युअल रूप से कुछ चीजें कीं। ओपी के वास्तविक प्रश्न का सामान्यीकरण करने के लिए:

#Column headers
print("", end="\t")
for team in teams_list:
    print(" ", team, end="")
print()
# rows
for team, row in enumerate(data):
    teamlabel = teams_list[team]
    while len(teamlabel) < 9:
        teamlabel = " " + teamlabel
    print(teamlabel, end="\t")
    for entry in row:
        print(entry, end="\t")
    print()

ouputs:

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

लेकिन यह अब अन्य उत्तरों की तुलना में अधिक सरल नहीं लगता है, शायद इस लाभ के साथ कि इसे किसी और आयात की आवश्यकता नहीं है। लेकिन @ कैम्पकेथ का जवाब पहले से ही मिल गया है और यह अधिक मजबूत है क्योंकि यह लेबल लंबाई की एक विस्तृत विविधता को संभाल सकता है।


1
इस पर मेटा मेटा पर चर्चा की गई है ।stackoverflow.com
Félix Gagnon-Grenier
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.