Formato Python String ()

O método string format () formata a string dada em uma saída melhor em Python.

A sintaxe do format()método é:

 template.format (p0, p1,…, k0 = v0, k1 = v1,…)

Aqui, p0, p1,… são argumentos posicionais e, k0, k1,… são argumentos de palavra-chave com valores v0, v1,… respectivamente.

E o modelo é uma mistura de códigos de formato com espaços reservados para os argumentos.

String format () Parâmetros

format()método aceita qualquer número de parâmetros. Porém, é dividido em dois tipos de parâmetros:

• Parâmetros posicionais - lista de parâmetros que podem ser acessados ​​com índice de parâmetro entre chaves(index)
• Parâmetros de palavra-chave - lista de parâmetros do tipo chave = valor, que pode ser acessada com a chave do parâmetro entre chaves(key)

Valor de retorno do formato String ()

O format()método retorna a string formatada.

Como funciona o formato String ()?

O format()lê os tipos de argumentos passados ​​e os formata de acordo com os códigos de formato definidos na string.

Para argumentos posicionais

Aqui, o Argumento 0 é uma string "Adam" e o Argumento 1 é um número flutuante 230,2346.

Observação: a lista de argumentos começa em 0 em Python.

A string "Hello (0), your balance is (1:9.3f)"é a string do modelo. Contém os códigos de formato para formatação.

As chaves são apenas espaços reservados para os argumentos a serem colocados. No exemplo acima, (0) é o espaço reservado para "Adam" e (1: 9.3f) é o espaço reservado para 230.2346.

Como a string do modelo faz referência a format()argumentos como (0)e (1), os argumentos são argumentos posicionais. Ambos também podem ser referenciados sem os números como ()e o Python os converte internamente em números.

Internamente,

• Visto que "Adam" é o ^0º argumento, ele é colocado no lugar de (0). Visto que, (0)não contém nenhum outro código de formato, ele não executa nenhuma outra operação.
• No entanto, não é o caso para 1 ^st argumento 230,2346. Aqui, (1:9.3f)coloca 230.2346 em seu lugar e executa a operação 9.3f.
• f especifica que o formato está lidando com um número flutuante. Se não for especificado corretamente, ele apresentará um erro.
• A parte antes de "." (9) especifica a largura / preenchimento mínimo que o número (230,2346) pode ter. Neste caso, 230.2346 é atribuído um mínimo de 9 lugares, incluindo o ".".
  Se nenhuma opção de alinhamento for especificada, ele será alinhado à direita dos espaços restantes. (Para strings, é alinhado à esquerda.)
• A parte após o "." (3) trunca a parte decimal (2346) até o número fornecido. Neste caso, 2346 é truncado após 3 casas.
  Os números restantes (46) são arredondados, resultando em 235.

Para argumentos de palavras-chave

Usamos o mesmo exemplo acima para mostrar a diferença entre palavras-chave e argumentos posicionais.

Aqui, em vez de apenas os parâmetros, usamos um valor-chave para os parâmetros. Ou seja, name = "Adam" e blc = 230,2346.

Como esses parâmetros são referenciados por suas chaves como (nome) e (blc: 9.3f), eles são conhecidos como palavra-chave ou argumentos nomeados.

Internamente,

• O marcador de posição (nome) é substituído pelo valor de nome - "Adam". Uma vez que não contém nenhum outro código de formato, "Adam" é colocado.
• Para o argumento blc = 230.2346, o marcador (blc: 9.3f) é substituído pelo valor 230.2346. Mas antes de substituí-lo, como no exemplo anterior, ele executa a operação 9.3f nele.
  Isso gera 230,235. A parte decimal é truncada após 3 casas e os dígitos restantes são arredondados. Da mesma forma, a largura total é atribuída a 9, deixando dois espaços à esquerda.

Formatação básica com formato ()

O format()método permite o uso de marcadores de posição simples para formatação.

Exemplo 1: formatação básica para argumentos padrão, posicionais e de palavra-chave

 # default arguments print("Hello (), your balance is ().".format("Adam", 230.2346)) # positional arguments print("Hello (0), your balance is (1).".format("Adam", 230.2346)) # keyword arguments print("Hello (name), your balance is (blc).".format(name="Adam", blc=230.2346)) # mixed arguments print("Hello (0), your balance is (blc).".format("Adam", blc=230.2346))

Resultado

Olá Adam, seu saldo é 230,2346. Olá Adam, seu saldo é 230,2346. Olá Adam, seu saldo é 230,2346. Olá Adam, seu saldo é 230,2346.

Nota: No caso de argumentos mistos, os argumentos de palavra-chave devem sempre seguir os argumentos posicionais.

Formatação de números com formato ()

Você pode formatar números usando o especificador de formato fornecido a seguir:

Exemplo 2: formatação de número simples

 # integer arguments print("The number is:(:d)".format(123)) # float arguments print("The float number is:(:f)".format(123.4567898)) # octal, binary and hexadecimal format print("bin: (0:b), oct: (0:o), hex: (0:x)".format(12))

Resultado

 O número é: 123 O número é: 123,456790 bin: 1100, out: 14, hex: c

Exemplo 3: formatação de número com preenchimento para int e flutuantes

 # integer numbers with minimum width print("(:5d)".format(12)) # width doesn't work for numbers longer than padding print("(:2d)".format(1234)) # padding for float numbers print("(:8.3f)".format(12.2346)) # integer numbers with minimum width filled with zeros print("(:05d)".format(12)) # padding for float numbers filled with zeros print("(:08.3f)".format(12.2346))

Resultado

1 2 1 2 3 4 1 2. 2 3 5 0 0 0 1 2 0 0 1 2. 2 3 5

Aqui,

• na primeira instrução, (:5d)recebe um argumento inteiro e atribui uma largura mínima de 5. Como nenhum alinhamento é especificado, ele é alinhado à direita.
• Na segunda declaração, você pode ver que a largura (2) é menor que o número (1234), portanto, não ocupa nenhum espaço à esquerda, mas também não trunca o número.
• Ao contrário dos inteiros, os floats possuem partes inteiras e decimais. E a largura mínima definida para o número é para ambas as partes como um todo, incluindo "." .
• Na terceira instrução, (:8.3f)trunca a parte decimal em 3 casas, arredondando os 2 últimos dígitos. E o número, agora 12,235, ocupa uma largura de 8 como um todo, deixando 2 casas à esquerda.
• Se você quiser preencher as casas restantes com zero, coloque um zero antes que o especificador de formato faça isso. Ele funciona tanto para inteiros quanto para flutuantes: (:05d)e (:08.3f).

Exemplo 4: formatação de número para números assinados

 # show the + sign print("(:+f) (:+f)".format(12.23, -12.23)) # show the - sign only print("(:-f) (:-f)".format(12.23, -12.23)) # show space for + sign print("(: f) (: f)".format(12.23, -12.23))

Resultado

+12,230000 -12,230000 12,230000 -12,230000 1 2. 2 3 0 0 0 0 - 1 2. 2 3 0 0 0 0

Formatação de números com alinhamento

Os operadores and =são usados ​​para alinhamento quando atribuídos a uma certa largura aos números.

Exemplo 5: formatação de números com alinhamento à esquerda, direita e centro

 # integer numbers with right alignment print("(:5d)".format(12)) # float numbers with center alignment print("(:^10.3f)".format(12.2346)) # integer left alignment filled with zeros print("(:<05d)".format(12)) # float numbers with center alignment print("(:=8.3f)".format(-12.2346))

Resultado

1 2 1 2. 2 3 5 1 2 0 0 0 - 1 2. 2 3 5

Observação: o alinhamento à esquerda preenchido com zeros para números inteiros pode causar problemas, pois o terceiro exemplo retorna 12000, em vez de 12

Formatação de string com format ()

Como números, a string pode ser formatada de maneira semelhante com format().

Example 6: String formatting with padding and alignment

 # string padding with left alignment print("(:5)".format("cat")) # string padding with right alignment print("(:>5)".format("cat")) # string padding with center alignment print("(:^5)".format("cat")) # string padding with center alignment # and '*' padding character print("(:*^5)".format("cat"))

Output

 c a t c a t c a t * c a t * 

Example 7: Truncating strings with format()

 # truncating strings to 3 letters print("(:.3)".format("caterpillar")) # truncating strings to 3 letters # and padding print("(:5.3)".format("caterpillar")) # truncating strings to 3 letters, # padding and center alignment print("(:^5.3)".format("caterpillar"))

Output

 c a t c a t c a t 

Formatting class and dictionary members using format()

Python internally uses getattr() for class members in the form ".age". And, it uses __getitem__() lookup for dictionary members in the form "(index)".

Example 8: Formatting class members using format()

 # define Person class class Person: age = 23 name = "Adam" # format age print("(p.name)'s age is: (p.age)".format(p=Person()))

Output

 Adam's age is: 23 

Here, Person object is passed as a keyword argument p.

Inside the template string, Person's name and age are accessed using .name and .age respectively.

Example 9: Formatting dictionary members using format()

 # define Person dictionary person = ('age': 23, 'name': 'Adam') # format age print("(p(name))'s age is: (p(age))".format(p=person))

Output

 Adam's age is: 23 

Similar to class, person dictionary is passed as a keyword argument p.

Inside the template string, person's name and age are accessed using (name) and (age) respectively.

There's an easier way to format dictionaries in Python using str.format(**mapping).

 # define Person dictionary person = ('age': 23, 'name': 'Adam') # format age print("(name)'s age is: (age)".format(**person))

** is a format parameter (minimum field width).

Arguments as format codes using format()

You can also pass format codes like precision, alignment, fill character as positional or keyword arguments dynamically.

Example 10: Dynamic formatting using format()

 # dynamic string format template string = "(:(fill)(align)(width))" # passing format codes as arguments print(string.format('cat', fill='*', # dynamic float format template num = "(:(align)(width).(precision)f)" # passing format codes as arguments print(num.format(123.236,>

 * * c a t * * 1 2 3 . 2 4 

 import datetime # datetime formatting date = datetime.datetime.now() print("It's now: (:%Y/%m/%d %H:%M:%S)".format(date)) # complex number formatting complexNumber = 1+2j print("Real part: (0.real) and Imaginary part: (0.imag)".format(complexNumber)) # custom __format__() method class Person: def __format__(self, format): if(format == 'age'): return '23' return 'None' print("Adam's age is: (:age)".format(Person()))

 It's now: 2016/12/02 04:16:28 Real part: 1.0 and Imaginary part: 2.0 Adam's age is: 23 

 # __str__() and __repr__() shorthand !r and !s print("Quotes: (0!r), Without Quotes: (0!s)".format("cat")) # __str__() and __repr__() implementation for class class Person: def __str__(self): return "STR" def __repr__(self): return "REPR" print("repr: (p!r), str: (p!s)".format(p=Person()))

 Citações: 'gato', sem citações: cat repr: REPR, str: STR