অজগরের ফ্লোটগুলির সহজ সুন্দর মুদ্রণ?

Question 1

আমার কাছে ফ্লোটের একটি তালিকা রয়েছে। আমি যদি 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]

Question 2

এটি একটি পুরানো প্রশ্ন তবে আমি সম্ভাব্য উপকারী কিছু যুক্ত করব:

আমি জানি আপনি কাঁচা পাইথন তালিকায় আপনার উদাহরণটি লিখেছেন, তবে আপনি যদি এর numpyপরিবর্তে অ্যারেগুলি ব্যবহার করার সিদ্ধান্ত নেন (যা আপনার উদাহরণে পুরোপুরি বৈধ হবে, কারণ আপনি মনে করছেন সংখ্যার অ্যারেগুলি নিয়ে কাজ করছেন) তবে এই আদেশটি (প্রায় অবিকল) রয়েছে আপনি বলেছেন:

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

বা আপনার ক্ষেত্রে আরও ভাল যদি আপনি এখনও দেখতে চান তবে সত্যিকারের সংখ্যার দশমিক दशকটি দেখতে চান, তবে উদাহরণস্বরূপ শিরোনামের শূন্য থেকে মুক্তি পান, বিন্যাসের স্ট্রিংটি ব্যবহার করুন %g:

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

কেবল একবার মুদ্রণের জন্য এবং বৈশ্বিক আচরণ পরিবর্তন না করার জন্য, np.array2stringউপরের মত একই আর্গুমেন্টগুলি ব্যবহার করুন ।

Question 3

যেহেতু কোনও নুন এটি যোগ করেছে, এটি লক্ষ করা উচিত যে পাইথন ২.++ থেকে এগিয়ে যাওয়া স্ট্রিং ফর্ম্যাটিং করার প্রস্তাবিত উপায়টি রয়েছে format, পাইথন 3+ এর জন্য প্রস্তুত হওয়ার জন্য।

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

নতুন স্ট্রিং গঠনের বাক্য গঠন ব্যবহার করা শক্ত নয় এবং এখনও বেশ শক্তিশালী।

আমি যদিও এটি হতে পারে pprintকিছু হতে পারে, কিন্তু আমি কিছুই খুঁজে পাই নি।

Question 4

আরও একটি স্থায়ী সমাধান সাবক্লাস হয় 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হ'ল এটি কোডটি ভঙ্গ করে যা স্পষ্টভাবে একটি ভেরিয়েবলের ধরণের সন্ধান করে। তবে যতদূর আমি বলতে পারি, এটিই কেবল সমস্যা problem এবং একটি সাধারণ x = map(float, x)রূপান্তর পূর্বাবস্থায় ফিরে আসে prettyfloat।

দুঃখজনকভাবে, আপনি কেবল বানর-প্যাচ করতে পারবেন না float.__repr__, কারণ এটি floatঅপরিবর্তনীয়।

আপনি যদি সাবক্লাস করতে না চান floatতবে কোনও ফাংশন সংজ্ঞায়িত করতে কিছু মনে করেন না, map(f, x)তার চেয়ে অনেক বেশি সংক্ষিপ্ত[f(n) for n in x]

Question 5

আপনি করতে পারেন:

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

Question 6

মনে রাখবেন আপনি "% .2f" (উদাহরণ: "% .2f" * 10) এর মতো স্ট্রিংকেও গুণ করতে পারেন।

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

Question 7

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

এটি মুদ্রণের সময় বাইনারি উপস্থাপনায় গোলাকার ত্রুটিগুলি এড়ানো যাবে, কোনও নির্দিষ্ট নির্ভুলতার সীমাবদ্ধতার পরিচয় না দিয়ে (সাথে গঠনের মতো "%.2f"):

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

Question 8

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

Question 9

একটি রাউন্ডিং রুটিন ব্যবহার করা সবচেয়ে সহজ বিকল্প হতে হবে:

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]

Question 10

উল্লেখযোগ্য সংখ্যার সংখ্যা নিয়ন্ত্রণ করতে, বিন্যাস নির্দিষ্টকারী% 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]

আপনি যদি উল্লেখযোগ্য অঙ্কের সংখ্যায় নমনীয়তা চান তবে পরিবর্তে এফ-স্ট্রিং ফর্ম্যাটিং ব্যবহার করুন:

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]

Question 11

আমি বিশ্বাস করি যে পাইথন ৩.১ কোনও কোড পরিবর্তন না করেই ডিফল্টরূপে তাদের আরও ভাল প্রিন্ট করবে। তবে অযথাই যদি আপনি এমন কোনও এক্সটেনশান ব্যবহার করেন যা পাইথন ৩.১ এর সাথে কাজ করার জন্য আপডেট হয়নি

Question 12

লিস্ট কমপগুলি আপনার বন্ধু।

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

Question 13

আপনি পান্ডা ব্যবহার করতে পারেন।

এখানে একটি তালিকার একটি উদাহরণ রয়েছে:

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

এবং ডেটা ফ্রেমে ডিক দেওয়ার অন্য একটি উপায়:

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

Question 14

পাইথন ৩.6 হিসাবে, আপনি এফ-স্ট্রিংগুলি ব্যবহার করতে পারেন:

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

Question 15

প্রথমত, সংগ্রহে থাকা উপাদানগুলি তাদের পুনরায় মুদ্রণ করে। আপনার সম্পর্কে __repr__এবং শিখতে হবে__str__ ।

এটি মুদ্রণ repr (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)

Question 16

ফ্লোটের টিপলগুলির একটি তালিকা আউটপুট দেওয়ার জন্য প্রিন্ট ব্যবহার করার চেষ্টা করার সময় আমি এই সমস্যার মধ্যে পড়েছিলাম। নেস্টেড বোধগম্যতা একটি খারাপ ধারণা হতে পারে তবে আমি যা করেছি তা এখানে:

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])

আমি প্রথমে জেনারেটর এক্সপ্রেশন ব্যবহার করেছি, তবে পিপ্রিন্টটি কেবল জেনারেটরকে তিরস্কার করেছে ...

Question 17

আমার এই সমস্যাটি ছিল, তবে এগুলির সমাধানগুলির মধ্যে আমি ঠিক যা চেয়েছিলাম ঠিক তেমনটি করেনি (আমি চাই মুদ্রিত আউটপুটটি একটি বৈধ অজগর অভিব্যক্তি হোক), সুতরাং এটি সম্পর্কে কীভাবে:

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]

(আমি জানি। ফর্ম্যাট () আরও মানসম্পন্ন সমাধান বলে মনে করা হয় তবে আমি এটি আরও পাঠযোগ্য বলে মনে করি)

Question 18

আমি সাইলেন্টগোস্টের মন্তব্যের সাথে একমত, লুপের জন্য এটি খারাপ নয়। আপনি যা চান তা অর্জন করতে পারেন:

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

Question 19

নীচের কোডটি আমার কাছে ভাল কাজ করে।

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