Uso e exemplos do método format() da string Python

Métodos de String do Python

O método format() da string formata o valor especificado e o insere no placeholder da string.
Os placeholders são definidos com chaves {}. Para mais informações sobre placeholders, consulte a seção 'Placeholder' abaixo.
O método format() retorna uma string formatada.

A sintaxe do método format() é:

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

aqui, p0, p1,...são parâmetros posicionais e k0, k1,...parâmetros nomeados com valor v0, v1,...。

e, o template é uma mistura de códigos de formatação e marcadores de posição.

parâmetros do string format()

o método format() aceita uma quantidade arbitrária de parâmetros. No entanto, eles são divididos em dois tipos de parâmetros:

• parâmetros posicionais -a lista de parâmetros que pode ser acessada usando o índice do parâmetro dentro dos chaves {index}

• parâmetros nomeados -a lista de parâmetros do tipo chave=valor, que pode ser acessada usando a chave do parâmetro dentro dos chaves {key}

o valor retornado pelo string format()

o método format() retorna uma string formatada.

como funciona o string format()?

o método format() lê o tipo dos parâmetros passados e os formata com base nos códigos de formatação definidos na string.

para parâmetros posicionais

aqui, o parâmetro 0 é a string "Adam", o parâmetro1é um número de ponto flutuante230.2346。

Atenção:　na Python, a lista de parâmetros começa no 0.

a string "Hello {0}, your balance is {1:9.3f}" é uma string de template. Isso contém códigos de formatação usados para formatação.

chaves são apenas marcadores de posição para os parâmetros a serem colocados. No exemplo acima, {0} é o marcador de posição para "Adam", {1:9.3f} é230.2346os marcadores de posição.

porque as strings de template referenciam os parâmetros format() como {0} e {1}, então esses parâmetros são parâmetros posicionais. Eles também podem ser referenciados sem números, porque {} e o Python convertem internamente para números.

f} referenciado, então eles são chamados de parâmetros nomeados ou parâmetros com nome.

• porque "Adam" é o 0 ^deé um parâmetro, então é colocado na posição {0}. Como {0} não contém nenhum outro código de formatação, ele não executa nenhuma outra operação.

• no entanto, o primeiro parâmetro230.2346não é assim. Aqui, {1:9.3f} será230.2346colocado em sua posição e executado9.3Antes de substituí-lo, ele realiza

• f especifica o formato que está tratando números de ponto flutuante. Se não for especificado corretamente, ele emitirá um erro.

• a parte antes do ponto (9especifica o número (230.2346é a largura mínima que pode ser usada/preechimento. Neste caso,230.2346é alocado pelo menos9de posições, incluindo o ponto.
  se não for especificado a opção de alinhamento, será alinhado para a direita do resto dos espaços. (Para strings, ele alinha para a esquerda.)

• a parte decimal após o ponto (3será truncado para o número especificado. Neste caso,2346será truncado para o número especificado. Neste caso,3346depois será truncado2346。
  O número restante (46será arredondado, e a saída será235。

Para parâmetros nomeados

Usamos o mesmo exemplo acima para mostrar a diferença entre parâmetros nomeados e posicionais.

Aqui, não só usamos parâmetros, mas também usamos chaves e valores como parâmetros. Isso é name="Adam" e blc=230.2346。

由于这些参数是由它们的键作为{name}和{blc:9.3Esses parâmetros são definidos por suas chaves como {name} e {blc:

f} referenciado, então eles são chamados de parâmetros nomeados ou parâmetros com nome.

• Internamente,-O marcador {name} substitui o valor de name

• “Adam”. Porque não contém nenhum outro código de formatação, foi colocado "Adam". 230.2346para o parâmetro blc =9.3，o marcador {blc:230.2346f} será substituído pelo valor9.3Antes de substituí-lo, ele realiza
  operação f.230.235。A parte decimal está3é truncado, e o resto dos números é arredondado. Da mesma forma, a largura total é distribuída9，deixando dois espaços à esquerda.

Formatação básica usando format()

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

Exemplo1：Padrão, formato básico de parâmetros posicionais e nomeados

# Parâmetros padrão
print("Olá {}, seu saldo é {}.".format("Adam",　230.2346))
# Parâmetros posicionais
print("Olá {0}, seu saldo é {1}.format("Adam",　230.2346))
# Parâmetros nomeados
print("Olá {name}, seu saldo é {blc}.".format(name="Adam", blc=230.2346))
# Parâmetros mistos
print("Olá {0}, seu saldo é {blc}.".format("Adam", blc=230.2346))

Quando o programa é executado, todas as saídas serão as mesmas:

Olá Adam, seu saldo é　230.2346.
Olá Adam, seu saldo é　230.2346.
Olá Adam, seu saldo é　230.2346.
Olá Adam, seu saldo é　230.2346.

Atenção:Para parâmetros mistos, os parâmetros nomeados devem sempre seguir os parâmetros posicionais.

Formatação de número usando format()

Você pode usar os especificadores de formato a seguir para configurar o formato numérico:

Exemplo2：Formato numérico simples

# Parâmetro inteiro
print("数字:{:d}".format(123))
#　浮点参数
print("浮点数:{:f}".format(123.4567898))
print("Número: {:=d}".format(
# Parâmetro flutuante12))

当您运行该程序时，输出将是：

print("Número flutuante: {:=f}".format(　123
# Formatação de octal, binário e hexadecimal123.456790
print("bin: {0:b}, oct: {0:o}, hex: {0:x}".format(　110Número:　14Número flutuante:

Exemplo3bin:

0,　oct:
print("{:5d}".format(12))
,　hex:　c
print("{:2d}".format(1234))
：Preenchimento de número com int e float
print("{:8.3f}".format(12.2346))
# Inteiro com largura mínima
# Preenchimento de número flutuante5d}".format(12))
# Largura não funciona para números maiores que o preenchimento
# Preenchimento de número flutuante8.3f}".format(12.2346))

当您运行该程序时，输出将是：

　　　121234　　12.23500012# Inteiro com largura mínima de 012.235

Aqui,

• # Preenchimento de número flutuante com zeros5print("{:=0500

• No primeiro comando, {:2d} usando parâmetro inteiro e especificando largura mínima1234。Como não foi especificado o modo de alinhamento, ele alinha-se à direita.

• No segundo comando, você pode ver a largura (

• ）menor que o número (8.3），portanto, não é necessário deixar nenhum espaço à esquerda e também não truncará o número.3Diferente dos inteiros, os números flutuantes têm parte inteira e decimal. E o comprimento mínimo definido para esse número é o total dos dois partes, incluindo o ponto '.'.12.235No terceiro comando, {:8f} Truncando a parte decimal para2dígitos, arredonde os últimos dois dígitos. E agora, o número é

• espaços. Mantenha o espaço à esquerda, a largura total é5Se você quiser preencher o resto dos espaços com zeros, coloque zeros antes do marcador de formato. Isso se aplica a inteiros e números flutuantes: {:=08.3f}. {:=d} e {:=0

Exemplo4：Formatação de número com sinal

# Exibição+sinal #
print("{:+f} {:=+f}".format(12.23,　-12.23))
# Exibição apenas-sinal #
print("{:-f} {:=-f}".format(12.23,　-12.23))
# Exibição+espaço em branco do sinal #
print("{:=f} {:=f}".format(12.23,　-12.23))

当您运行该程序时，输出将是：

+12.230000　-12.230000
12.230000　-12.230000　12.230000　-12.230000

Formatação de número alinhado

Quando você especifica uma largura para o número, os operadores < e > são usados para alinhamento. ^>=

Exemplo5：Formatação de número à esquerda, à direita e centralizada

# Número inteiro à direita
print("{:5d}".format(12))
# Número flutuante com alinhamento centralizado
print("{:^10.3f}".format(12.2346))
# Alinhamento à esquerda do inteiro
print("{:<05d}".format(12))
# Alinhamento centralizado do número flutuante
print("{:=8.3f}".format(-12.2346))

当您运行该程序时，输出将是：

　　　12　　12.235　　12000-　12.235

Atenção:Para o terceiro exemplo, o preenchimento com zeros para alinhamento à esquerda pode causar problemas, a exemplo return12000 em vez de12。

Formatação de string usando format()

Como número, você pode formatar a string de maneira semelhante usando format()

Exemplo6：Formatação de string com preenchimento e alinhamento

# Alinhamento à esquerda do preenchimento de string
print("{:5}".format("cat"))
# Alinhamento à direita do preenchimento de string
print("{:>}}5}".format("cat"))
#中心对齐的字符串填充
print("{:^5}".format("cat"))
# 中心对齐的字符串填充
# 和 '*' 填充字符
print("{:*^5}".format("cat"))

当您运行该程序时，输出将是：

cat     cat cat　*cat*

Exemplo7：使用format()截断字符串

# 将字符串截断为3个字母
print("{:.3}".format("caterpillar"))
# 将字符串截断为3个字母
# 和 填充
print("{:5.3}".format("caterpillar"))
# 将字符串截断为3个字母,
# 填充和中心对齐
print("{:^5.3}".format("caterpillar"))

当您运行该程序时，输出将是：

catcat     cat

使用format()格式化类和字典成员

Python内部getattr()以“ .age”形式用于类成员。并且，它使用__getitem__()查找“[index]”形式的字典成员。

Exemplo8：使用format()格式化类成员

# define Person class
class　Person:
　　　　age =　23
　　　　name = "Adam"
# 格式化age
print("{p.name}年龄是 : {p.age}".format(p=Person()))

当您运行该程序时，输出将是：

Adam's 年龄是 :　23

在这里，Person对象作为关键字参数p传递。

在模板字符串中，分别使用.name和.age访问Person的name和age。

Exemplo9：使用format()格式化字典成员

# 定义Person字典
person = {'age':　23, 'name': 'Adam'}
# 格式化age
print("{p[name]}'s age is: {p[age]}".format(p=person))

当您运行该程序时，输出将是：

Adam's age is:　23

与class类似，person字典作为关键字参数p传递。

在模板字符串中，分别使用[name]和[age]访问人员的name和age。

有一种更简单的方法可以使用Python格式化字典str.format(**mapping)。

# 定义Person字典
person = {'age':　23, 'name': 'Adam'}
# 格式化age
print("{name}'s age is: {age}".format(**person))

** 是格式参数（最小字段宽度）。

使用format()作为格式代码的参数

您还可以动态传递格式代码，例如精度，对齐，填充字符作为位置或关键字参数。

Exemplo10：使用format()的动态格式化

# 动态字符串格式模板
string = "{:{fill}{align}{width}}"
# Pass format codes as parameters
print(string.format('cat', fill='*', align='^', width=5))
# Dynamic floating-point format template
num = "{:\{align}\{width}\.\{precision}f}"
# Pass format codes as parameters
print(num.format(123.236, align='<' width=8, precision=2))

A saída do programa ao executá-lo é:

**cat**123.24

Aqui,

• In the first example, "cat" is the formatted positional argument. Similarly, fill='*'align='^' and width=5are keyword arguments.

• In the template string, these keyword parameters are not as ordinary strings to be printed, but as actual format codes retrieved: fill, align, and width.
  the parameters will replace the corresponding named placeholders, and the string "cat" will be formatted accordingly.

• Similarly, in the second example,123.236are positional arguments, and align, width, and precision are passed to the template string as format codes.

Other format options with format()

format() also supports specific type formatting options, such as datetime format and complex number format.

format() internally calls __format__() from datetime, and format() accesses the attributes of complex numbers.

You can easily overwrite the __format__() method of any object for custom formatting.

Exemplo11: Use format() and rewrite __format__() method for specific type formatting

import datetime
# Date and time format
date = datetime.datetime.now()
print("Current time: \{:\%Y/\%m/\%d \%H:\%M:\%S".format(date))
# Complex number format
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()))

A saída do programa ao executá-lo é:

Hora atual:　2020/04/17　14:33:02
Parte real:　1.0 e parte imaginária:　2.0
A idade de Adam é:　23

Aqui,

• Para datetime:
  A data e hora atual são passadas como parâmetro de posição para o método format().
  E, internamente, usa o método __format__(), o format() pode acessar ano, mês, dia, hora, minuto e segundo.

• Para números complexos:
  1 + 2j é convertido internamente para o objeto ComplexNumber.
  A seguir, acessa seus atributos real e imag, os números são formatados.

• Reescrever __format__():
  Como datetime, você pode reescrever seu próprio método __format__() para configurações de formatação personalizadas, quando acessado como {age}, o formato retornará a idade

Você também pode usar as funcionalidades de __str__() e __repr__() dos objetos, usando a abreviação do formato().

Como __format__(), você pode facilmente reescrever os métodos __str__() e __repr__().

Exemplo12：Uso de abreviações de __str__() e __repr__() com format()

#　__str__()　e　__repr__()　abreviados como　!r　e　!s
print("Quotes:　{0!r},　Without　Quotes:　{0!s}".format("cat"))
#　__str__()　e　__repr__()　implementam a classe
class　Person:
　　　　def　__str__(self):
　　　　　　　　return　"STR"
　　　　def　__repr__(self):
　　　　　　　　return　"REPR"
print("repr:　{p!r},　str:　{p!s}".format(p=Person()))

A saída do programa ao executá-lo é:

Quotes:　'cat',　Without　Quotes:　cat
repr:　REPR,　str:　STR

Métodos de String do Python