अजगर में तैरने की आसान सुंदर छपाई?

Question

मेरे पास झांकियों की सूची है। अगर मैं बस printयह, यह इस तरह से पता चलता है:

[9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]

मैं उपयोग कर सकता था print "%.2f", जिसे forसूची को पार करने के लिए लूप की आवश्यकता होगी , लेकिन तब यह अधिक जटिल डेटा संरचनाओं के लिए काम नहीं करेगा। मुझे कुछ पसंद आएगा (मैं इसे पूरी तरह से बना रहा हूं)

>>> import print_options
>>> print_options.set_float_precision(2)
>>> print [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
[9.0, 0.05, 0.03, 0.01, 0.06, 0.08]

Answer 1

यह एक पुराना सवाल है, लेकिन मैं संभावित रूप से उपयोगी कुछ जोड़ूंगा:

मुझे पता है कि आपने अपना उदाहरण कच्ची पायथन सूची में लिखा था, लेकिन यदि आप numpyइसके बजाय सरणियों का उपयोग करने का निर्णय लेते हैं (जो आपके उदाहरण में पूरी तरह से वैध होगा, क्योंकि आप संख्याओं के सरणियों के साथ काम कर रहे हैं), वहाँ है (लगभग वास्तव में) यह आदेश आपको आपने कहा:

import numpy as np
np.set_printoptions(precision=2)

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

np.set_printoptions(formatter={"float_kind": lambda x: "%g" % x})

सिर्फ एक बार छपाई करने और वैश्विक व्यवहार को न बदलने के लिए, np.array2stringऊपर दिए गए तर्कों के साथ उपयोग करें ।

Answer 2

जैसा कि किसी ने इसे जोड़ा नहीं है, यह ध्यान दिया जाना चाहिए कि पायथन 2.6+ से आगे बढ़ते हुए , स्ट्रिंग बनाने के लिए अनुशंसित तरीका है format, पायथन 3+ के लिए तैयार होने के लिए।

print ["{0:0.2f}".format(i) for i in a]

नया स्ट्रिंग फ़ॉर्मेटिंग सिंटैक्स उपयोग करने के लिए कठिन नहीं है, और फिर भी काफी शक्तिशाली है।

हालांकि मैं pprintकुछ भी हो सकता है, लेकिन मुझे कुछ नहीं मिला।

Comments

यह वह था जिसका मैंने उपयोग किया था लेकिन मैंने .replace("'", "")उन अल्पविरामों से छुटकारा पाने के लिए जोड़ा । str(["{0:0.2f}".format(i) for i in a]).replace("'", "")

— स्टाइनर हर्टन होस्कुलडसन 15

यह स्ट्रिंग की एक सूची तैयार करेगा। मुद्रित आउटपुट में, प्रत्येक तत्व इसके ''चारों ओर होता है। उदाहरण के लिए, इसके लिए a=[0.2222, 0.3333], यह उत्पादन करेगा ['0.22', '0.33']।

— jdhao

सुप्रीम और अल्पविराम के निकालने के लिए, आप का उपयोग करना चाहिए' '.join([{0:0.2f}".format(i) for i in a])

— Neb

Answer 3

एक अधिक स्थायी समाधान उपवर्ग के लिए है float:

>>> class prettyfloat(float):
    def __repr__(self):
        return "%0.2f" % self

>>> x
[1.290192, 3.0002, 22.119199999999999, 3.4110999999999998]
>>> x = map(prettyfloat, x)
>>> x
[1.29, 3.00, 22.12, 3.41]
>>> y = x[2]
>>> y
22.12

उपवर्ग के साथ समस्या floatयह है कि यह कोड को तोड़ता है जो स्पष्ट रूप से एक चर के प्रकार की तलाश में है। लेकिन अभी तक मैं बता सकता हूं, कि इसके साथ एकमात्र समस्या है। और एक साधारण x = map(float, x)रूपांतरण को पूर्ववत करता है prettyfloat।

वास्तव में, आप सिर्फ बंदर-पैच नहीं कर सकते float.__repr__, क्योंकि floatअपरिवर्तनीय है।

यदि आप उप-वर्ग नहीं करना चाहते हैं float, लेकिन किसी फ़ंक्शन को परिभाषित करने में कोई आपत्ति नहीं है, तो map(f, x)यह बहुत अधिक संक्षिप्त है[f(n) for n in x]

Comments

मैंने सोचा होगा कि एक सरल समाधान था, लेकिन आपका उत्तर स्पष्ट रूप से सबसे अच्छा है, क्योंकि आप केवल एक ही हैं जो वास्तव में मेरे प्रश्न का उत्तर देते हैं।

— static_rtti

वह केवल एक ही है जो वास्तव में आपके प्रश्न का उत्तर देता है। उत्तर देने वाले को निराश नहीं करना, लेकिन आप एक प्रश्न को स्पष्ट नहीं कर सकते हैं और फिर हम जिस जानकारी के साथ काम कर रहे थे, उसके आधार पर बाकी के उत्तरदाताओं को हल्का कर सकते हैं।

— जेड स्मिथ

मेरे मूल प्रश्न में उल्लेख किया गया था कि मैंने लूप के लिए एक अच्छा समाधान नहीं माना था (मेरे लिए एक सूची की समझ समान है, लेकिन मैं मानता हूं कि यह स्पष्ट नहीं था)। मैं अगली बार स्पष्ट होने की कोशिश करूँगा।

— static_rtti

[f (n) x में n के लिए] नक्शे की तुलना में बहुत अधिक पायथोनिक है (f, x)।

— रॉबर्ट टी। मैकगिबोन

मैं जरूरी तौर पर उपवर्ग फ्लोटिंग के पक्ष में नहीं हूं, लेकिन मुझे नहीं लगता कि टाइपिंग जाँच एक वैध तर्क है। जब जाँच प्रकार, isinstanceका उपयोग किया जाना चाहिए, की समानता नहीं type()। जब इसे सही ढंग से किया जाता है, तो फ्लोट का एक उपवर्ग अभी भी फ्लोट के रूप में गिना जाएगा।

— जोंडो

Answer 4

तुम कर सकते हो:

a = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
print ["%0.2f" % i for i in a]

Comments

यह ['9.00', '0.05', '0.03', '0.01', '0.06', '0.08'] - उद्धरण चिह्नों के साथ छपेगा, जो आप आमतौर पर नहीं चाहते हैं (मैं झांकियों की एक वैध सूची रखना पसंद करता हूं मुद्रित)

— एमिल

Answer 5

ध्यान दें कि आप "% .2f" जैसे एक स्ट्रिंग को गुणा कर सकते हैं (उदाहरण: "% .2f" * 10)।

>>> print "%.2f "*len(yourlist) % tuple(yourlist)
2.00 33.00 4.42 0.31 

Comments

बहुत खूबसूरत! मुझे यह पसंद है

— नाथन फ़ेलमैन

-1 भयानक हैक। स्ट्रिंग्स के स्वरूपित टुकड़ों में शामिल हों, कृपया

— इधर

तो kaizer.se, क्या आप "" .join (["%। 2f"% x के लिए x अपनी सूची में प्रस्तावित कर रहे हैं)। मुझे अजगर में इस तरह का निर्माण करना होगा।

— ग्रीग लिंड

हां, मैं प्रस्ताव करता हूं कि " ".join("%.2f" % x for x in yourlist)बिदाई स्वरूप स्ट्रिंग और प्रक्षेप मान एक बदसूरत पायथन मुहावरे का उपयोग करने की तुलना में बहुत खराब है।

— u0b34a0f6ae 19

यह जिज्ञासा है। लिस्ट फेल होने पर टपल क्यों काम कर रहा है? "टपल" के बिना, यह त्रुटि करता है। क्यों?

— जूनो पार्क

Answer 6

print "[%s]"%", ".join(map(str,yourlist))

यह एक निश्चित परिशुद्धता बाधा (जैसे बनाने के साथ) को पेश किए बिना, बाइनरी प्रतिनिधित्व में गोल त्रुटियों से बच जाएगा "%.2f" ):

[9.0, 0.053, 0.0325754, 0.0108928, 0.0557025, 0.0793303]

Answer 7

l = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]

अजगर 2:

print ', '.join('{:0.2f}'.format(i) for i in l)

अजगर 3:

print(', '.join('{:0.2f}'.format(i) for i in l))

आउटपुट:

9.00, 0.05, 0.03, 0.01, 0.06, 0.08

Comments

पता नहीं क्यों यह अधिक नहीं है। एक समाधान जो तीसरे पक्ष के पुस्तकालयों पर भरोसा नहीं करता है!

— Fl.pf।

Answer 8

सबसे आसान विकल्प एक गोल दिनचर्या का उपयोग करना चाहिए:

import numpy as np
x=[9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]

print('standard:')
print(x)
print("\nhuman readable:")
print(np.around(x,decimals=2))

यह उत्पादन का उत्पादन करता है:

standard:
[9.0, 0.053, 0.0325754, 0.0108928, 0.0557025, 0.0793303]

human readable:
[ 9.    0.05  0.03  0.01  0.06  0.08]

Comments

यह एक महान जवाब है

— jjz

Answer 9

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

Comments

पायथन 3.1 सबसे कम दशमलव प्रतिनिधित्व को मुद्रित करेगा जो उस फ्लोट मान के लिए मैप करता है। उदाहरण के लिए: >>> ए, बी = फ्लोट (1.1), फ्लोट (1.1000000000000001) >>> 1. 1.1000000000000001 >>> बी 1.1000000000000001 >>> प्रिंट (ए, बी) 1.1 1.1

— मैट बोहेम

Answer 10

सूची comps अपने दोस्त हैं।

print ", ".join("%.2f" % f for f in list_o_numbers)

कोशिश करो:

>>> nums = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999]
>>> print ", ".join("%.2f" % f for f in nums)
9.00, 0.05, 0.03, 0.01

Comments

जनरेटर की अभिव्यक्ति और भी बेहतर होगी: ", .join ("%। 2f "% f में f के लिए list_o_numbers)

— efotinis

@efotinis ने अभी तक मेरे प्रदर्शनों की सूची में शामिल नहीं किया है, लेकिन आप सही हैं - यह बहुत सेक्सी है।

— जेड स्मिथ

@Jed: कृपया पूछे जाने वाले प्रश्न, अनुभाग पढ़ें "अन्य लोगों को मेरा सामान संपादित कर सकते हैं ?!": stackoverflow.com/faq । प्रत्येक संपादन एक अच्छा नहीं है, लेकिन यह एक वास्तविक सुधार था। शायद आप अपने उत्तर में दोनों तकनीकों को सूचीबद्ध कर सकते हैं, और अंतर के बारे में एक नोट जोड़ सकते हैं?

— Stephan202

Answer 11

महत्वपूर्ण अंकों की संख्या को नियंत्रित करने के लिए, प्रारूप निर्दिष्ट% g का उपयोग करें।

एमील के समाधान का नाम सुंदरला 2f दें। यहाँ एक संशोधित है:

prettylist2g = lambda l : '[%s]' % ', '.join("%.2g" % x for x in l)

उपयोग:

>>> c_e_alpha_eps0 = [299792458., 2.718281828, 0.00729735, 8.8541878e-12]
>>> print(prettylist2f(c_e_alpha_eps0)) # [299792458.00, 2.72, 0.01, 0.00]
>>> print(prettylist2g(c_e_alpha_eps0)) # [3e+08, 2.7, 0.0073, 8.9e-12]

यदि आप महत्वपूर्ण अंकों की संख्या में लचीलापन चाहते हैं, तो इसके बजाय f-string फ़ॉर्मेटिंग का उपयोग करें:

prettyflexlist = lambda p, l : '[%s]' % ', '.join(f"{x:.{p}}" for x in l)
print(prettyflexlist(3,c_e_alpha_eps0)) # [3e+08, 2.72, 0.0073, 8.85e-12]

Answer 12

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

यहाँ एक सूची के साथ एक उदाहरण दिया गया है:

In: import pandas as P
In: P.set_option('display.precision',3)
In: L = [3.4534534, 2.1232131, 6.231212, 6.3423423, 9.342342423]
In: P.Series(data=L)
Out: 
0    3.45
1    2.12
2    6.23
3    6.34
4    9.34
dtype: float64

यदि आपके पास एक डी है, और आप पंक्तियों के रूप में इसकी कुंजी चाहते हैं:

In: d
Out: {1: 0.453523, 2: 2.35423234234, 3: 3.423432432, 4: 4.132312312}

In: P.DataFrame(index=d.keys(), data=d.values())
Out:  
    0
1   0.45
2   2.35
3   3.42
4   4.13

और DataFrame को तानाशाही देने का एक और तरीका:

P.DataFrame.from_dict(d, orient='index')

Answer 13

सबसे पहले, एक संग्रह के अंदर के तत्व अपनी रीप्र प्रिंट करते हैं। आप के बारे में सीखना चाहिए __repr__और __str__।

यह प्रिंट रीप्र (1.1) और प्रिंट 1.1 के बीच का अंतर है। आइए अभ्यावेदन के बजाय उन सभी तार से जुड़ें:

numbers = [9.0, 0.053, 0.0325754, 0.0108928, 0.0557025, 0.07933]
print "repr:", " ".join(repr(n) for n in numbers)
print "str:", " ".join(str(n) for n in numbers)

Comments

नोट: पायथन 2.7 में, इस उदाहरण के लिए, "repr" लाइन और "str" ​​लाइन के परिणाम समान हैं।

— टूलमेकरसेव

Answer 14

मैं बस इस समस्या में भाग गया, जबकि फ़्लोट्स के tuples की एक सूची के उत्पादन के लिए pprint का उपयोग करने की कोशिश कर रहा था। नेस्टेड कॉम्प्रिहेंशन एक बुरा विचार हो सकता है, लेकिन यहाँ मैंने क्या किया है:

tups = [
        (12.0, 9.75, 23.54),
        (12.5, 2.6, 13.85),
        (14.77, 3.56, 23.23),
        (12.0, 5.5, 23.5)
       ]
pprint([['{0:0.02f}'.format(num) for num in tup] for tup in tups])

मैंने पहली बार जनरेटर के भावों का इस्तेमाल किया, लेकिन जेनरेटर ने पुन: उत्पन्न कर दिया ...

Answer 15

पायथन 3.6 के रूप में, आप f- स्ट्रिंग्स का उपयोग कर सकते हैं:

list_ = [9.0, 0.052999999999999999, 
         0.032575399999999997, 0.010892799999999999, 
         0.055702500000000002, 0.079330300000000006]

print(*[f"{element:.2f}" for element in list_])
#9.00 0.05 0.03 0.01 0.06 0.08

कोड को बहुत पठनीय रखते हुए आप प्रिंट मापदंडों का उपयोग कर सकते हैं:

print(*[f"{element:.2f}" for element in list_], sep='|', end='<--')
#9.00|0.05|0.03|0.01|0.06|0.08<--

Answer 16

मुझे यह समस्या थी, लेकिन यहाँ कोई भी समाधान ठीक वैसा नहीं हुआ जैसा मैं चाहता था (मैं चाहता हूं कि मुद्रित आउटपुट एक मान्य अजगर अभिव्यक्ति हो), तो इस बारे में कैसे:

prettylist = lambda l : '[%s]' % ', '.join("%.2f" % f for f in l)

उपयोग:

>>> ugly = [9.0, 0.052999999999999999, 0.032575399999999997,
            0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
>>> prettylist = lambda l : '[%s]' % ', '.join("%.2f" % f for f in l)
>>> print prettylist(ugly)
[9.00, 0.05, 0.03, 0.01, 0.06, 0.08]

(मुझे पता है .format () को अधिक मानक समाधान माना जाता है, लेकिन मुझे यह अधिक पठनीय लगता है)

Answer 17

मैं साइलेंटगॉस्ट की टिप्पणी से सहमत हूं, क्योंकि लूप इतना बुरा नहीं है। आप जो चाहें हासिल कर सकते हैं:

l = [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
for x in l: print "%0.2f" % (x)

Comments

जबकि छोरों के लिए बदसूरत नहीं हैं, यह उपयोग बहुत अच्छा नहीं है।

— जेड स्मिथ

Answer 18

नीचे दिया गया कोड मेरे लिए अच्छा काम करता है।

list = map (lambda x: float('%0.2f' % x), list)