पायथन में एक सूची कैसे प्रिंट करें "अच्छी तरह से"

Question 1

PHP में, मैं यह कर सकता हूँ:

echo '<pre>'
print_r($array);
echo '</pre>'

पायथन में, मैं वर्तमान में बस यही करता हूं:

print the_list

हालांकि, यह डेटा के एक बड़े जंबो का कारण होगा। क्या इसे पढ़ने योग्य पेड़ में अच्छी तरह से मुद्रित करने का कोई तरीका है? (इंडेंट के साथ)?

Question 2

from pprint import pprint
pprint(the_list)

Question 3

डिबगिंग करते समय एक त्वरित हैक जो आयात किए बिना काम करता है pprintवह सूची में शामिल होना होगा '\n'।

>>> lst = ['foo', 'bar', 'spam', 'egg']
>>> print '\n'.join(lst)
foo
bar
spam
egg

Question 4

बस प्रिंट फ़ंक्शन तर्क में सूची को "अनपैकिंग" करके और विभाजक के रूप में एक नई रेखा (\ n) का उपयोग कर।

प्रिंट (* lst, sep = '\ n')

lst = ['foo', 'bar', 'spam', 'egg']
print(*lst, sep='\n')

foo
bar
spam
egg

Question 5

आपका मतलब कुछ इस तरह है ...:

>>> print L
['this', 'is', 'a', ['and', 'a', 'sublist', 'too'], 'list', 'including', 'many', 'words', 'in', 'it']
>>> import pprint
>>> pprint.pprint(L)
['this',
 'is',
 'a',
 ['and', 'a', 'sublist', 'too'],
 'list',
 'including',
 'many',
 'words',
 'in',
 'it']
>>>

...? आपके सरसरी विवरण से, मानक पुस्तकालय मॉड्यूल प्रिंट पहली बात है जो दिमाग में आती है; हालाँकि, यदि आप उदाहरण इनपुट और आउटपुट का वर्णन कर सकते हैं (ताकि किसी को आपकी मदद करने के लिए PHP सीखना न हो; ;-), तो हमारे लिए और अधिक विशिष्ट मदद की पेशकश करना संभव हो सकता है!

Question 6

import json
some_list = ['one', 'two', 'three', 'four']
print(json.dumps(some_list, indent=4))

आउटपुट:

[
    "one",
    "two",
    "three",
    "four"
]

Question 7

https://docs.python.org/3/library/pprint.html

यदि आपको पाठ की आवश्यकता है (उदाहरण के लिए शाप के साथ उपयोग करने के लिए):

import pprint

myObject = []

myText = pprint.pformat(myObject)

तब myTextचर कुछ समान होगा php var_dumpया print_r। अधिक विकल्पों, तर्कों के लिए प्रलेखन की जाँच करें।

Question 8

जैसा कि अन्य जवाबों से पता चलता है कि पाइंट मॉड्यूल चाल करता है।
फिर भी, डिबगिंग के मामले में जहां आपको पूरी सूची को कुछ लॉग फ़ाइल में डालने की आवश्यकता हो सकती है, किसी को pprintat के साथ मॉड्यूल लॉगिंग के साथ pformat विधि का उपयोग करना पड़ सकता है ।

import logging
from pprint import pformat

logger = logging.getLogger('newlogger')
handler = logging.FileHandler('newlogger.log')

formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
handler.setFormatter(formatter)

logger.addHandler(handler) 
logger.setLevel(logging.WARNING)

data = [ (i, { '1':'one',
           '2':'two',
           '3':'three',
           '4':'four',
           '5':'five',
           '6':'six',
           '7':'seven',
           '8':'eight',
           })
         for i in xrange(3)
      ]

logger.error(pformat(data))

और अगर आपको इसे सीधे फाइल में लॉग इन करने की आवश्यकता है, तो स्ट्रीम कीवर्ड का उपयोग करके किसी को आउटपुट स्ट्रीम निर्दिष्ट करना होगा। संदर्भ

from pprint import pprint

with open('output.txt', 'wt') as out:
   pprint(myTree, stream=out)

देखें स्टेफानो सैनफिलिपो का जवाब

Question 9

के लिए अजगर 3 , मैं के रूप में बात की ही तरह कर shxfee के जवाब :

def print_list(my_list):
    print('\n'.join(my_list))

a = ['foo', 'bar', 'baz']
print_list(a)

जो आउटपुट देता है

foo
bar
baz

एक तरफ के रूप में, मैं जल्दी से एक पांडा डेटाफ़्रेम में कॉलम देखने के लिए एक समान सहायक फ़ंक्शन का उपयोग करता हूं

def print_cols(df):
    print('\n'.join(df.columns))

Question 10

जैसा कि अन्य जवाबों ने उल्लेख किया है, pprintएक महान मॉड्यूल है जो वह करेगा जो आप चाहते हैं। हालाँकि यदि आप इसे आयात नहीं करना चाहते हैं और विकास के दौरान डिबगिंग आउटपुट प्रिंट करना चाहते हैं, तो आप इसके आउटपुट का अनुमान लगा सकते हैं।

कुछ अन्य उत्तर तार के लिए ठीक काम करते हैं, लेकिन यदि आप उन्हें एक क्लास ऑब्जेक्ट के साथ आज़माते हैं तो यह आपको त्रुटि देगा TypeError: sequence item 0: expected string, instance found।

अधिक जटिल वस्तुओं के लिए, सुनिश्चित करें कि कक्षा में एक __repr__विधि है जो आपके द्वारा वांछित संपत्ति की जानकारी प्रिंट करती है:

class Foo(object):
    def __init__(self, bar):
        self.bar = bar

    def __repr__(self):
        return "Foo - (%r)" % self.bar

और फिर जब आप आउटपुट प्रिंट करना चाहते हैं, तो बस अपनी सूची को strइस तरह से फ़ंक्शन में मैप करें :

l = [Foo(10), Foo(20), Foo("A string"), Foo(2.4)]
print "[%s]" % ",\n ".join(map(str,l))

आउटपुट:

 [Foo - (10),
  Foo - (20),
  Foo - ('A string'),
  Foo - (2.4)]

तुम भी नेस्टेड सुंदर मुद्रण का एक रूप प्राप्त करने की __repr__विधि को ओवरराइड करने जैसी चीजें कर सकते हैं list:

class my_list(list):
    def __repr__(self):
        return "[%s]" % ",\n ".join(map(str, self))

a = my_list(["first", 2, my_list(["another", "list", "here"]), "last"])
print a

देता है

[first,
 2,
 [another,
 list,
 here],
 last]

दुर्भाग्य से कोई दूसरे स्तर का इंडेंटेशन नहीं है, लेकिन एक त्वरित डिबग के लिए यह उपयोगी हो सकता है।

Question 11

तुम भी अपनी सूची गर्त कर सकते हैं:

def fun():
  for i in x:
    print(i)

x = ["1",1,"a",8]
fun()