Python’da format dönüştürme, format (sıfır doldurma, üstel gösterim, onaltılık, vb.)

iş

Python’da bir sayıyı veya dizeyi çeşitli biçimlere dönüştürmek (biçimlendirmek) için, yerleşik format() işlevini veya str.format() dize yöntemini kullanın.

Bu bölümde, aşağıdaki işlevlerin nasıl kullanılacağını açıklayacağız.

  • yerleşik işlev (örneğin programlama dilinde)format()
  • dize yöntemistr.format()

Ayrıca, aşağıdaki biçime dönüştürmek için biçim belirtimi dizesi örnek kodla açıklanmıştır.

  • Sola dayalı, Merkeze dayalı, Sağa dayalı
  • sıfır dolgu
  • İşaret (artı veya eksi)
  • Rakam ayırıcı (virgül, alt çizgi)
  • İkili, sekizli ve onaltılı sayılar
  • Ondalık noktadan sonraki basamak sayısını belirtin
  • Anlamlı rakamlar (anlamlı basamak sayısı)
  • üstel gösterim
  • Yüzde gösterimi

Python 3.6’dan bu yana, daha özlü hale getirmek için str.format() string yöntemine f-strings (f-strings) eklendiğini unutmayın.

Yerleşik işlev: format()

format(), standart bir Python yerleşik işlevi olarak sağlanır.

Anahat aşağıdaki gibidir.

  • format(value, format_spec)
    • İlk argüman:value
      Orijinal değer. String str, sayı int, kayan nokta, vb.
    • ikinci argümanformat_spec
      Biçim belirtimi dizesi. dize dizisi
    • Dönüş değeri: biçimlendirilmiş bir dize str

Örnekler aşağıda gösterilmiştir. Biçim dizgilerinin türleri ve bunların nasıl yazılacağı daha sonra açıklanacaktır.

Bu örnekte, ilk argüman olarak sayısal değişmezleri ve dize değişmezlerini kullandık, ancak elbette bu değerleri içeren değişkenleri kullanabilirsiniz.

s = format(255, '04x')
print(s)
print(type(s))
# 00ff
# <class 'str'>

print(format('center', '*^16'))
# *****center*****

Dize yöntemi str.format()

str tipi için bir format() yöntemi de vardır.

dizgedeki format() yöntemini çağıran {}, ikame alanı olarak adlandırılır ve format() yönteminin bağımsız değişkeni ile değiştirilir.

Biçim belirtimi dizesi, {} ikame alanına ve ardından “:” yazılmalıdır.

Dönüş değeri, biçimlendirilmiş bir dize str’dir.

Yukarıda açıklanan yerleşik format() işlevine eşdeğer işlem aşağıdaki gibidir.

s = '{:04x}'.format(255)
print(s)
print(type(s))
# 00ff
# <class 'str'>

print('{:*^16}'.format('center'))
# *****center*****

Yine, argüman olarak sayısal değişmez değerler ve dize değişmezleri kullanıyoruz, ancak elbette değişkenler de kabul edilebilir.

İkame alanları için bağımsız değişkenler belirtme

Argümanları sırayla belirtin (varsayılan)

Birden çok ikame alanı {} olabilir ve varsayılan olarak yöntem bağımsız değişkenleri sırayla işlenir. {} içindeki biçim belirtimi dizesi atlanırsa, yalnızca str() tarafından bir dizeye dönüştürülür.

Bir dizgeye değişken değerler eklemek ve bunları yazdırmak için kullanışlıdır.

print('{}-{}-{}'.format('100', '二百', 300))
# 100-二百-300

Tamsayı değerleri için konumsal bir bağımsız değişken belirtin

{} içinde {0} veya {1} gibi bir tamsayı değeri belirtilirse, çıktı bağımsız değişkenlerin sırasına bağlı olacaktır. Aynı numara tekrar tekrar kullanılabilir. Bu, aynı değeri bir dizgeye eklemek istediğinizde kullanışlıdır.

print('{0}-{1}-{0}'.format('foo', 'bar'))
# foo-bar-foo

Rasgele adlar (dizeler) için anahtar sözcük bağımsız değişkenleri belirtin

Ayrıca {} içinde herhangi bir ad belirtebilir ve bunu bir anahtar kelime bağımsız değişkeni olarak girebilirsiniz.

print('{day}/{month}/{year}/'.format(day=11, month=1, year=2018))
# 11/1/2018

Bağımsız değişken olarak bir liste veya sözlük belirtin

Listeler ve sözlükler argüman olarak belirtilebilir.

Bir ikame alanındaki bir listenin dizinini veya bir sözlüğün anahtarını belirtmek için [] kullanın. “‘” ve “” tırnak işaretlerinin sözlük anahtarlarını belirtmek için kullanılmadığını unutmayın.

Aynı argümanı tekrar tekrar kullanmak istiyorsanız, yukarıda açıklandığı gibi bir tamsayı değeri veya bir dize (ad) belirtmeniz gerekir.

l = ['one', 'two', 'three']
print('{0[0]}-{0[1]}-{0[2]}'.format(l))
# one-two-three

d1 = {'name': 'Alice', 'age': 20}
d2 = {'name': 'Bob', 'age': 30}
print('{0[name]} is {0[age]} years old.\n{1[name]} is {1[age]} years old.'.format(d1, d2))
# Alice is 20 years old.
# Bob is 30 years old.

Listeye * ekleyip argüman olarak belirterek konumsal bir argüman olarak veya sözlüğe ** ekleyip argüman olarak belirterek bir anahtar kelime argümanı olarak genişletilebilir.

l = ['one', 'two', 'three']
print('{}-{}-{}'.format(*l))
# one-two-three

d = {'name': 'Alice', 'age': 20}
print('{name} is {age} years old.'.format(**d))
# Alice is 20 years old.

Kıvrımlı parantezlerin açıklaması {}

format() yönteminde küme parantezleri {,} yazmak istiyorsanız, {{,}} gibi iki kez tekrarlayın. Ters eğik çizgilerden kaçılamayacağını unutmayın.

print('{{}}-{num}-{{{num}}}'.format(num=100))
# {}-100-{100}

biçimlendirilmiş dize

Her iki durumda da, biçimi belirtmek için, {} içindeki tamsayı değerinden veya ad dizesinden sonra “:format dizesi” yazın.

print('{num:x}'.format(num=255))
# ff

print('{day}/{month:02}/{year:02}/'.format(day=11, month=1, year=2018))
# 11/01/2018

Aşağıda, bir biçim dizesi kullanarak biçimin nasıl belirleneceğini açıklayacağız. Örnek kod, str.format() dize yöntemini kullanır, ancak yerleşik işlev format() ile aynı biçim dizesi kullanılabilir. Yerleşik format() işlevinde, biçim belirtimi dizesi ikinci argüman olarak belirtilir.

Sola dayalı, Merkeze dayalı, Sağa dayalı

Aşağıda sola hizalı, ortaya hizalı, sağa hizalı vb. hizalayabilirsiniz. Toplam karakter sayısını sayı olarak belirtin.

  • <
  • ^
  • >
print('left  : {:<10}'.format(100))
print('center: {:^10}'.format(100))
print('right : {:>10}'.format(100))
# left  : 100       
# center:    100    
# right :        100

Doldurulacak bir karakter de belirtebilirsiniz. Atlanırsa, yukarıdaki örnekte olduğu gibi bir boşluktur.

Tek bir karakter olduğu sürece çift baytlık karakterler kullanabilirsiniz.

print('left  : {:*<10}'.format(100))
print('center: {:a^10}'.format(100))
print('right : {:鬼>10}'.format(100))
# left  : 100*******
# center: aaa100aaaa
# right : 鬼鬼鬼鬼鬼鬼鬼100

> (-,+) işaretini dikkate almaz. = kullanırsanız, işaretin ardından belirtilen karakter gelir. + belirtmek istiyorsanız, =’den sonra + yazın. İşaret işlemenin ayrıntıları daha sonra açıklanacaktır.

print('sign: {:0>10}'.format(-100))
print('sign: {:0=10}'.format(-100))
print('sign: {:0=+10}'.format(100))
# sign: 000000-100
# sign: -000000100
# sign: +000000100

<, ^ ve > dizeler için belirtilebilir, ancak = değeri ValueError hatasıyla sonuçlanır. Bir dize için = kullanmak istiyorsanız, onu int() kullanarak bir sayıya dönüştürmeniz gerekir.

# print('sign: {:0=10}'.format('-100'))
# ValueError: '=' alignment not allowed in string format specifier

print('sign: {:0=10}'.format(int('-100')))
# sign: -000000100

Aynısı kayan noktalı sayılar için de geçerlidir. Ondalık noktalar da bir karakter olarak sayılır.

print('left  : {:*<10}'.format(1.23))
print('center: {:a^10}'.format(1.23))
print('right : {:鬼>10}'.format(1.23))
# left  : 1.23******
# center: aaa1.23aaa
# right : 鬼鬼鬼鬼鬼鬼1.23

print('sign: {:0>10}'.format(-1.23))
print('sign: {:0=10}'.format(-1.23))
print('sign: {:0=+10}'.format(1.23))
# sign: 00000-1.23
# sign: -000001.23
# sign: +000001.23

Listeler, demetler vb. olduğu gibi belirtilirse bir hataya neden olur ve str() kullanılarak dizelere dönüştürülebilir.

l = [0, 1]
print(type(l))
# <class 'list'>

# print('{:*^16}'.format(l))
# TypeError: unsupported format string passed to list.__format__

print(type(str(l)))
# <class 'str'>

print('{:*^16}'.format(str(l)))
# *****[0, 1]*****

Sola hizalı, ortaya hizalı ve sağa hizalı için ljust(), center() ve rjust() olarak adlandırılan özel dize yöntemleri de vardır.

0 doldurma

Sıfır doldurma ile basamak sayısını ayarlamak istiyorsanız, doldurulacak karakteri 0’a ayarlayın ve sağa yaslayın.

Sıfır doldurma durumunda, hizalama sembolü atlanırsa, = belirtilmiş gibi işlenir.

print('zero padding: {:0=10}'.format(100))
print('zero padding: {:010}'.format(100))
# zero padding: 0000000100
# zero padding: 0000000100

print('zero padding: {:0=10}'.format(-100))
print('zero padding: {:010}'.format(-100))
# zero padding: -000000100
# zero padding: -000000100

#HATA!

# print('zero padding: {:010}'.format('-100'))
# ValueError: '=' alignment not allowed in string format specifier

Sıfır doldurma için ayrıca zfill() adlı özel bir dize yöntemi vardır.

İşaret (artı veya eksi)

Varsayılan olarak, yalnızca negatif sayılar bir işaretle (eksi-) işaretlenir.

Biçimlendirme belirtimi dizesine + eklendiğinde, pozitif sayılar için bir işaret (artı +) da görüntülenir. Bir boşluk eklenirse, pozitif sayının başında bir boşluk görüntülenir ve basamak sayısı negatif sayı ile hizalanır.

print('sign: {}'.format(100))
print('sign: {}'.format(-100))
# sign: 100
# sign: -100

print('sign: {:+}'.format(100))
print('sign: {:+}'.format(-100))
# sign: +100
# sign: -100

print('sign: {: }'.format(100))
print('sign: {: }'.format(-100))
# sign:  100
# sign: -100

Yukarıda bahsedilen sıfır doldurma gibi rastgele karakterlerle doldururken dikkatli olun. + ve boşluk içermeyen varsayılan, pozitif sayıları bir karakterle daha doldurur.

print('sign: {:06}'.format(100))
print('sign: {:06}'.format(-100))
# sign: 000100
# sign: -00100

print('sign: {:+06}'.format(100))
print('sign: {:+06}'.format(-100))
# sign: +00100
# sign: -00100

print('sign: {: 06}'.format(100))
print('sign: {: 06}'.format(-100))
# sign:  00100
# sign: -00100

Bir hizalama sembolü kullanılıyorsa, işaret tanımlama sembolü, hizalama sembolünden sonra yazılmalıdır.

print('sign: {:_>6}'.format(100))
print('sign: {:_>6}'.format(-100))
# sign: ___100
# sign: __-100

print('sign: {:_>+6}'.format(100))
print('sign: {:_>+6}'.format(-100))
# sign: __+100
# sign: __-100

print('sign: {:_> 6}'.format(100))
print('sign: {:_> 6}'.format(-100))
# sign: __ 100
# sign: __-100

Rakam ayırıcı (virgül, alt çizgi)

Her üç basamakta bir virgül veya alt çizgi _ ayırıcısı ekleyin. Bu, büyük sayıların okunmasını kolaylaştırır. underscore_ öğesinin Python 3.6’da eklenen bir seçenek olduğunu ve bu nedenle önceki sürümlerde kullanılamayacağını unutmayın.

print('{:,}'.format(100000000))
# 100,000,000

print('{:_}'.format(100000000))
# 100_000_000

Kayan noktalı sayı kayan nokta türleri durumunda, yalnızca tamsayı kısmı sınırlandırılır.

print('{:,}'.format(1234.56789))
# 1,234.56789

İkili, sekizli ve onaltılı sayılar

Çıktı için sayısal değerleri ikili, sekizli ve onaltılı sayılara dönüştürür.

  • b: ikili
  • o: sekizli
  • d: ondalık
  • x,X: Onaltılık (büyük harfler büyük yazılır)
print('bin: {:b}'.format(255))
print('oct: {:o}'.format(255))
print('dec: {:d}'.format(255))
print('hex: {:x}'.format(255))
print('HEX: {:X}'.format(255))
# bin: 11111111
# oct: 377
# dec: 255
# hex: ff
# HEX: FF

Ayrıca 0-dolgu ile birleştirilebilir ve genellikle ikili ve onaltılık gösterimde rakamları hizalamak için kullanılır.

print('bin: {:08b}'.format(255))
print('oct: {:08o}'.format(255))
print('dec: {:08d}'.format(255))
print('hex: {:08x}'.format(255))
print('HEX: {:08X}'.format(255))
# bin: 11111111
# oct: 00000377
# dec: 00000255
# hex: 000000ff
# HEX: 000000FF

Sıfır doldurma karakterlerinin sayısının önek dikkate alınarak belirtilmesi gerektiğini unutmayın.

print('bin: {:#010b}'.format(255))
print('oct: {:#010o}'.format(255))
print('dec: {:#010d}'.format(255))
print('hex: {:#010x}'.format(255))
print('HEX: {:#010X}'.format(255))
# bin: 0b11111111
# oct: 0o00000377
# dec: 0000000255
# hex: 0x000000ff
# HEX: 0X000000FF

İkili ve onaltılı sayılar için yalnızca alt çizgi _ basamak ayırıcı eklenebilir (Python 3.6 veya üstü). 4 haneli ayırıcı kullanılır; sıfır doldurulmuş karakterlerin sayısı, alt çizgi sayısını da hesaba katmalıdır.

print('hex: {:08x}'.format(255))
print('hex: {:09_x}'.format(255))
print('hex: {:#011_x}'.format(255))
# hex: 000000ff
# hex: 0000_00ff
# hex: 0x0000_00ff

Yalnızca int tamsayı türü, biçimi ikili veya onaltılık biçime dönüştürebilir. Bir sayıya dönüştürmek için int() kullanabilirsiniz.

# print('hex: {:08x}'.format('255'))
# ValueError: Unknown format code 'X' for object of type 'str'

print('hex: {:08x}'.format(int('255')))
# hex: 000000ff

Ondalık noktadan sonraki basamak sayısını belirtin

Ondalık noktadan sonraki basamak sayısını belirtmek için aşağıdakileri yapın: n, basamak sayısıdır. Ondalık noktadan sonraki basamak sayısı, tamsayı kısmındaki basamak sayısından bağımsız olarak belirtilen basamak sayısı olur.
.[n]f

print('{:.2f}'.format(123.456))
print('{:.5f}'.format(123.456))
print('{:.3f}'.format(0.0001234))
# 123.46
# 123.45600
# 0.000

Ondalık noktanın sol tarafı, yukarıda açıklandığı gibi sola hizalı, ortaya hizalı, sağa hizalı veya sıfır dolgulu olarak belirtilebilir. Hedef değerin basamak sayısı belirtilen sayıdan fazla ise herhangi bir işlem yapılmaz. Hedef değerdeki basamak sayısı belirtilen basamak sayısından fazlaysa hiçbir şey yapılmaz.

print('{:>12.5f}'.format(123.456))
print('{:012.5f}'.format(123.456))
print('{:06.5f}'.format(123.456))
#    123.45600
# 000123.45600
# 123.45600

Ondalık noktadan sonra orijinal basamak sayısından daha az bir basamak sayısı belirtirseniz, değer yuvarlanır. Bunun en yakın tam sayıya değil, çift sayıya yuvarlama olduğuna dikkat edin, ör. 0,5, 0’a yuvarlanır.

print('{:.0f}'.format(0.4))
print('{:.0f}'.format(0.5))
print('{:.0f}'.format(0.6))
# 0
# 0
# 1

Genel yuvarlamayı kullanmak istiyorsanız, standart kitaplık ondalığının quantize() yöntemini kullanabilirsiniz.

üstel gösterim

Kayan noktalı bir kayan noktalı sayı bir dizgeye dönüştürüldüğünde, basamak sayısına bağlı olarak otomatik olarak üstel gösterimde yazılacaktır. Tamsayı türü int yapmaz.

print('{}'.format(0.0001234))
print('{}'.format(0.00001234))
# 0.0001234
# 1.234e-05

print('{}'.format(1234000000000000.0))
print('{}'.format(12340000000000000.0))
print('{}'.format(12340000000000000000000000))
# 1234000000000000.0
# 1.234e+16
# 12340000000000000000000000

Biçimlendirme belirtimi dizesinde e veya E belirtirseniz, her zaman üstel gösterime dönüştürebilirsiniz. Çıktıda kullanılan karakterler sırasıyla e ve E olacaktır.

print('{:e}'.format(0.0001234))
print('{:E}'.format(0.0001234))
# 1.234000e-04
# 1.234000E-04

Ondalık noktadan sonra basamak sayısını belirtmek de mümkündür. Tamsayı kısmı her zaman bir basamak olacak ve ondalık nokta belirtilen basamak sayısı olacaktır.

print('{:.5e}'.format(0.0001234))
print('{:.2E}'.format(0.0001234))
# 1.23400e-04
# 1.23E-04

print('{:.5e}'.format(987.65))
print('{:.2E}'.format(987.65))
# 9.87650e+02
# 9.88E+02

Sola hizalı, ortaya hizalı, sağa hizalı veya sıfır dolgulu belirtirseniz, e-, E+ vb.’nin de rakam (karakter) olarak sayılacağını unutmayın.

print('{:>12.5e}'.format(987.65))
print('{:012.2E}'.format(987.65))
#  9.87650e+02
# 00009.88E+02

Anlamlı rakamlar (anlamlı basamak sayısı)

Aşağıdakileri yaparak toplam basamak sayısını belirleyebilirsiniz. Sonuca bağlı olarak, otomatik olarak üstel gösterim kullanılacaktır. Ondalık noktadan sonra gelen sıfırların atlanacağını unutmayın.
.[n]g

print('{:.2g}'.format(123.456))
print('{:.3g}'.format(123.456))
print('{:.8g}'.format(123.456))
print('{:.3g}'.format(0.0001234))
# 1.2e+02
# 123
# 123.456
# 0.000123

g’yi atlarsanız, çıktı bir tamsayı olmayacaktır. g çoğu durumda aynıdır, ancak yalnızca çıktının bir tamsayı olduğu durumlarda.

print('{:.2}'.format(123.456))
print('{:.3}'.format(123.456))
print('{:.8}'.format(123.456))
print('{:.3}'.format(0.0001234))
# 1.2e+02
# 1.23e+02
# 123.456
# 0.000123

Aynı değeri işlersek, sırasıyla aşağıdakileri elde ederiz.

print('{:.3f}'.format(123.456))
print('{:.3e}'.format(123.456))
print('{:.3g}'.format(123.456))
print('{:.3}'.format(123.456))
# 123.456
# 1.235e+02
# 123
# 1.23e+02

print('{:.8f}'.format(123.456))
print('{:.8e}'.format(123.456))
print('{:.8g}'.format(123.456))
print('{:.8}'.format(123.456))
# 123.45600000
# 1.23456000e+02
# 123.456
# 123.456

g olması durumunda veya atlanırsa, ondalık noktadan sonraki sıfırlar atlanır, bu nedenle aynı sayıda anlamlı rakam (anlamlı basamak sayısı) vermek istiyorsanız, e veya E’nin üstel gösterimini kullanın. tamsayı kısmı her zaman bir basamaktır ve ondalık nokta belirtilen basamak sayısıdır, bu nedenle n anlamlı basamak çıktısı almak istiyorsanız, n-1’i belirtmeniz yeterlidir.

print('{:.4e}'.format(123.456))
print('{:.4e}'.format(0.000012345))
print('{:.4e}'.format(12))
# 1.2346e+02
# 1.2345e-05
# 1.2000e+01

Yüzde gösterimi

Biçimlendirme belirtimi dizesinde % belirtilirse, sayısal kayan nokta veya int değeri 100 ile çarpılır ve % ile bir dizeye dönüştürülür.

Ondalık noktadan sonra basamak sayısını belirtmek de mümkündür. Varsayılan, ondalık noktadan sonra altı basamaktır. Sola hizalama, ortaya hizalama, sağa hizalama ve sıfır doldurma da mevcuttur. % ayrıca bir karakter olarak sayılır.

print('{:%}'.format(0.12345))
print('{:.2%}'.format(0.12345))
# 12.345000%
# 12.35%

print('{:%}'.format(10))
print('{:.2%}'.format(10))
# 1000.000000%
# 1000.00%

print('{:>7.2%}'.format(0.12345))
print('{:07.2%}'.format(0.12345))
#  12.35%
# 012.35%
Copied title and URL