Contenido
1. Marcadores de formato y funciones str(), repr(), ascii()
(1) Marcadores de formato (conversores de formato)
(2) Funciones str(), repr(), ascii()
2. f Referencias a objetos en ' ', Expresiones de formato str.format() y str%()
3. Agregue los caracteres descritos en las expresiones de formato f'', str.format() y str%()
Explicación detallada del formato de cadenas de f'', str.format() y str%() en Python
A veces necesitamos procesar o describir el objeto al imprimir () la salida, para que la salida cumpla con nuestros requisitos, o presente mejor los resultados para nuestra comprensión (es decir, aumentar la legibilidad de los resultados de la salida), en este momento, podemos Realice algunas configuraciones relacionadas en el objeto de impresión de impresión, de modo que la salida de impresión de impresión se emita en un formato determinado para cumplir con nuestros requisitos de salida de impresión. Por lo general, usamos las cadenas de f'', str.format() y str%( ) Formateo (cadena formateada, salida formateada) para lograr el efecto de impresión de impresión. Por supuesto, f'', str.format() y str%() también se pueden usar en otros escenarios. El formato de cadena f'' a menudo se conoce como formato de cadena f-string.
1. Dar formato a marcadores de posición y funciones str(), repr(), ascii()
Para el uso específico del formato de cadena de f'', str.format() y str%(), estarán involucrados algunos marcadores de posición. Por lo tanto, aquí está el marcador de posición de formato python. Estos tres formatos de cadena también se pueden abreviar como formato f, formato de formato y formato de operador %.
(1) Marcador de posición de formato ( carácter de conversión de formato)
Marcador de posición de formato, el nombre originado en el lenguaje C, que indica que hay entrada o salida en esta posición (por ejemplo: se usa en funciones como scanf(), printf()), y el marcador de posición indica que los datos en un formato determinado son generado en esta posición. En python, también puede entenderse como un carácter de conversión de formato, y también significa realizar conversiones relacionadas para objetos. El nombre anterior se usa aquí. La Tabla 1-1 a continuación muestra varios marcadores de posición de formato comúnmente utilizados (caracteres de conversión de formato).
Tabla 1-1 Marcadores de posición de formato comúnmente utilizados (caracteres de conversión de formato)
| s |
String (mostrado por str()), también se puede usar ns, n representa el ancho de salida, es decir, el número de ocupantes de salida |
| r |
String (mostrar usando repr()), también se puede usar nr, n es el mismo que el anterior |
| a |
Cadena (pantalla ascii()), na, n igual que arriba también se puede usar |
| C |
Un solo carácter, también disponible nc, n igual que arriba |
| b |
Entero binario, solo se puede usar en f'', str.format(), nb también se puede usar, n es el mismo que el anterior |
| d |
Entero decimal, también disponible nd, n igual que arriba |
| o |
Entero octal, también disponible no, n igual que arriba |
| X |
Entero hexadecimal, puede usar X o nx, n es el mismo que el anterior |
| F |
Números decimales de coma flotante, es decir, decimales |
| .mf |
m es precisión, lo que significa retener m lugares decimales |
| n. mf |
n indica el ancho de salida, es decir, el número de posiciones de salida, m indica que se reservan m lugares decimales y .m puede ser predeterminado |
| mi |
Notación científica, forma exponencial, la base es e (equivalente a 10), y también se puede usar E |
| .a mí |
m significa mantener m decimales |
| n.me |
n indica el ancho de salida, es decir, el número de posiciones de salida, m indica que se reservan m lugares decimales y .m puede ser predeterminado |
| gramo |
Si el exponente es menor que -4 o mayor que 5, use e, de lo contrario, use d o f por defecto, o G |
| .mg |
Reserve m dígitos significativos (números), si el exponente es menor que -4 o mayor que m-1, entonces use e, de lo contrario, use d |
| n mg |
n es el ancho de salida, es decir, el número de lugares de salida, m es el mismo que el anterior, y el formato del valor es el mismo que el anterior, .m puede ser el valor predeterminado |
| % |
% carácter |
Los marcadores de posición de formato enumerados anteriormente agregarán los símbolos correspondientes en str%(), f'' y str.format(), por ejemplo: los marcadores de posición en str%() agregarán el símbolo %, y en f'' y str. Las expresiones de formato format() se utilizan en otros símbolos. str%() no admite la conversión a %b binario y mostrará un carácter de formato no compatible 'b'.
(2) Funciones str(), repr(), ascii()
El marcador de posición de formato s en la Tabla 1-1 usa el resultado de la función str() para obtener una cadena de texto legible por humanos. El marcador de posición de formato r usa el resultado de la función repr() para convertir el objeto en una forma que sea más adecuada para que la lea el intérprete, y su valor de retorno también es un tipo de cadena.Desde la perspectiva del uso, repr() función se suma a la expresión El papel de un par de comillas .
str(), repr() llaman respectivamente a los métodos __str__(), __repr__(), la clase de objeto contiene estos dos métodos, y todas las clases de Python heredan la clase de objeto, por lo que todas las clases de Python heredan el método __str__(), __repr__(). La función print llamará al método __str__() de forma predeterminada al imprimir, por lo que la salida de impresión de la función print se convierte automáticamente a un formato de cadena.
sr1 = 'Hello,Python\n'
#print打印默认调用了__str__()方法,显示出的文本字符串,适合人阅读,
#相当于执行了转义符\n。
print(sr1)
#repr(sr1)实际获得的值为"'Hello,Python\n'",
#但经过print打印调用了__str__()方法,显示为'Hello,Python\n'。
print(repr(sr1))
#上面相当于下面。
#格式占位符表示该位置会产生一个什么格式的数据。
#str%()中格式占位符都会增加符号%,下面%r表示该位置产生repr()函数返回的字符串格式的数据,
#实际也是依次引用右边小括号的实参进行格式化。
#下面print打印也调用了__str__()方法。
print('%r'%(sr1))
#数字的字符串格式。
sr2=str(123)
print(type(sr2),sr2)
#对于字符串,增加引号。
print(type(repr(sr2)),repr(sr2))
#对于非字符串的整型,增加引号。
print(type(repr(123)),repr(123))
print('%s'%(123))#s即为str()
print('%r'%(123))#r即为repr()
resultado de la operación:
La función repr() es equivalente a agregar un par de comillas, y la función eval() se puede usar para restaurar el resultado de repr() a los datos originales. Para el uso de la función de análisis eval, consulte el Capítulo 9 de este blog.
sr1 = 'Hello,Python'
#根据eval的执行特点,下面是可行的,但不能直接用eval(sr1)。
#eval执行了"'Hello,Python'",得到结果'Hello,Python',sr1引用了它。
sr1=eval(repr(sr1))
#print打印默认调用了__str__()方法,显示出的文本字符串,适合人阅读。
print(sr1)resultado de la operación:
Podemos reescribir el método __str__() o __repr__() en la clase, y la clase ejecutará automáticamente el método __str__() o __repr__() reescrito cuando se instancia. Esta ejecución automática es similar a __init__(), cuando ambos se anulan, __str__() se ejecuta de forma predeterminada.
class Group:
def __init__(self,name,age):
self.name = name
self.age = age
#返回类对象地址,打印出类对象地址。
print(Group('Bor',23))
class Member:
def __init__(self,name,age):
self.name = name
self.age = age
def __repr__(self):
return ('名字是：%s,年龄是：%d')%(self.name,self.age)
#重写了__repr__方法,类实例化时自动执行__repr__方法。
#打印自动执行__repr__方法的返回值。
print(Member('Bor',23))
class Student:
def __init__(self,name,age):
self.name = name
self.age = age
def __repr__(self):
return ('名字是：%s,年龄是：%d')%(self.name,self.age)
def __str__(self):
return ('name is %s,age is %d')%(self.name,self.age)
#重写了__repr__、__str__方法,类实例化时默认自动执行__str__方法。
#打印自动执行__str__方法的返回值。
print(Student('Bor',23))resultado de la operación:
El marcador de posición de formato a en la Tabla 1-1 usa el resultado de la función ascii() , y el retorno es el carácter decodificado de acuerdo con el estándar de codificación ASCII. Si no se puede codificar en ASCII, usará \x, \u ( o \U) Escape, y luego agregue comillas, similar a la función repr(), excepto que el estándar de codificación es diferente al decodificar.
sr1='abc\n'
#对字符串增加引号,是ASCII解码的字符串。
print(type(ascii(sr1)),ascii(sr1))
print('%a'%(sr1))
sr2='你好'
#对汉字字符串增加引号,不能用ASCII解码,则会用\x、\u进行转义。
print(type(ascii(sr2)),ascii(sr2))
print('%a'%(sr2))
n1=129
#对整型增加引号,是ASCII解码的数字字符串。
print(type(ascii(n1)),ascii(n1))
print('%a'%(n1))
print('\n')
print(type(repr(sr2)),repr(sr2))
print(type(sr2),sr2)
print(type(repr(n1)),repr(n1))
print(type(str(n1)),str(n1))
print('%s'%(n1))resultado de la operación:
El resultado de ascii() se decodifica o escapa usando el estándar de codificación ASCII y se agregan comillas. Los estándares de codificación de tipo y ASCII pueden participar en el siguiente contenido relacionado.
A continuación, describiremos el uso específico del formato de cadena de f'', str.format() y str%(). El formato de cadena f'' a menudo se conoce como formato de cadena f-string.
2. Referencias a objetos en expresiones de formato f'' , str.format() y str%()
Las formas básicas de referencias f'', str.format() y str%() a objetos son:
f'{name}', esta expresión no admite la referencia al objeto de parámetro, donde nombre representa el nombre (identidad del objeto), que es una referencia al objeto, y el nombre aquí no puede ser predeterminado;
'{name}'.format(), donde los paréntesis de format() son parámetros, que pueden ser parámetros posicionales o parámetros de palabra clave, es decir, se admite str.format(*args, **kwargs), y el nombre también se admite. used here La referencia del objeto del parámetro real, pero el nombre aquí es el número ordinal correspondiente al parámetro real posicional en format() (el número ordinal comienza desde 0) o la palabra clave del parámetro de palabra clave. es un parámetro real de palabra clave, el nombre no puede ser predeterminado, si las comillas indican la operación general de solo un parámetro real posicional o la operación general de cada parámetro real posicional en orden, entonces el nombre del número ordinal puede ser predeterminado, si la operación local se realiza en el parámetro actual posicional, significa el número ordinal El nombre no puede ser predeterminado;
'%(nombre)'% (), esta expresión no es adecuada para hacer referencia a parámetros de palabras clave, donde los paréntesis derechos () son parámetros, si el parámetro es un diccionario, puede usar el nombre para referirse al objeto en el diccionario, de lo contrario , nombre predeterminado. Además, si solo hay un parámetro entre paréntesis () a la derecha, los paréntesis pueden ser predeterminados.
La referencia de nombre de f'' no tiene nada que ver con los parámetros, pero las referencias de nombre de str.format() y str%() están relacionadas con los parámetros, y str.format() y str%() se refieren a la objetos en el diccionario muy especialmente, que es diferente de Hay diferencias en la referencia de parámetros de palabras clave. str.format() y str%() se refieren a objetos en el diccionario. Solo ciertos tipos de datos se pueden usar como nombres de referencia, y este nombre está en forma de identificadores (estilo), pero el nombre no necesariamente se ajusta al estándar (estándar) para la formación de identificadores. Para obtener detalles, consulte el siguiente ejemplo. El siguiente ejemplo es la referencia al objeto por cada expresión de formato.
sr1,sr2='ab','cd'
te1 = {'kr': 'ij', 10: 31, '12': 89,'15y':76}
lt1=[1,2,3]
print("f'':")
#f''是通过名称引用对象,对字典的键值的引用是通过键名引用,这也是字典的引用方式。
print(f'{sr1},{sr2},{te1},{te1["kr"]},{te1[10]},{te1["12"]},{te1["15y"]}')
print('\nstr.format():')
#对于位置实参,str.format()若是按顺序引用小括号()中的位置实参,{}中可缺省序数。
#不能出现有的有序数,有的缺省序数这种形式。对于关键字实参,关键字不能缺省。
print('{},{z},{},{}'.format(sr1,sr2,te1,z=3))
#但引用对象的局部的元素时,应该使用序数。
print('{0},{1[0]},{2}'.format(sr1,sr2,te1))
#序数代表了对应的位置实参。
print('{1},{2},{0}'.format(sr1,sr2,te1))
#下面是借助键名对位置参数字典中的对象(键值)进行引用,
#但不支持键名为数字字符串的,其它都支持,并且引用方式类似标识符引用,
#而不是直接使用键名(字典的引用方式)。
#下面键名10、'15y'类似标识符进行引用,但不支持数字字符串键名'12',
#注意,对参数te1里面再次进行引用,这时不再是参数引用。
print('{0[kr]},{0[10]},{0[15y]}'.format(te1))
#下面是关键字参数进行引用,因为函数的关键字参数对应为变量,关键字参数实际也是变量,
#而变量名(变量名也是标识符)的首个符号不能是数字,因此,下面只能使用关键字kr。
#下面是对实参**te1进行解包,对关键字参数进行引用,具体可以参加前面讲到的动态参数。
print('{kr}'.format(**te1))
#下面是对位置实参的引用。
print('{2},{0},{1}'.format(*lt1))
#str.format()可以通过关键字引用关键字实参,也可以引用其局部元素。
print('{y},{y[1]}'.format(y=[7,8,9]))
print('\nstr%():')
#str%()不适合引用关键字参数。
#格式占位符表示该位置会产生一个什么格式的数据。
#str%()中格式占位符都会增加符号%,下面%s表示该位置产生字符串格式的数据,
#实际也是依次引用右边小括号的实参进行格式化。
print('%s,%s'%(sr1,sr2))
#借助键名对位置参数字典中的对象进行引用,
#但不支持数字的键名,其它都支持,并且引用方式类似标识符引用,
#而不是直接使用键名(字典的引用方式)。
#下面键名'kr'、'12'、'15y'类似标识符进行引用,但不支持数字键名10。
print('%(kr)s,%(12)s,%(15y)s'%(te1))
print('\n通过路径引用对象:')
class AA:
a1=1
a2=2
print(f'{AA.a1},{AA.a2}')
print(f'{AA().a1},{AA().a2}')
#下面只能变成关键字参数才能引用。
print('{t.a1},{t.a2}'.format(t=AA))
print('{t.a1},{t.a2}'.format(t=AA()))
resultado de la operación:
El uso de f'', str.format() y str%() son complementarios hasta cierto punto, y cada uno tiene sus propias características. Además, f'' y str.format() no necesitan usar marcadores de posición. En el código anterior, f'' y str.format() no usan marcadores de posición, pero str%() requiere marcadores de posición. El nombre de f'' debe existir y no puede ser predeterminado.
En python , las referencias a objetos generalmente vienen en tres formas básicas. Una es hacer referencia al número de serie, por ejemplo: sr1[2], 2 es el índice. La otra es usar el nombre de la clave para hacer referencia, que es la referencia de la naturaleza del nombre de la clave, como: diccionario dt1['bd'], 'bd' es el nombre de la clave. Otra es usar identificadores para referirse, por ejemplo: variable num=856, num es una variable. Del ejemplo anterior, podemos ver que las referencias de nombre de str.format() y str%() tienen ciertas particularidades, hay una referencia a un identificador aproximado, pero no se ajusta a la especificación del identificador.
Tres, f'' , str.format() y str%() expresiones de formato para aumentar los caracteres descritos
sr1='abc'
k1=len(sr1)
#f''
print(f'字符串{sr1}的长度是{k1}')
#或用str.format()
print('字符串{0}的长度是{1}'.format(sr1,k1))
#或用str%()
print('字符串%s的长度是%d'%(sr1,k1))resultado de la operación:
Tres expresiones de formato de f'', str.format() y str%() se enumeran arriba. La impresión anterior es una impresión en un formato determinado. Este tipo de salida formateada hace que el resultado impreso sea más legible. Si usa print(sr1,k1), obviamente es menos legible. No es intuitivo simplemente mirar el resultado, pero la impresión con formato descriptivo anterior, el resultado de la impresión nos permite saber de un vistazo.
Explicación detallada del formato de cadenas de f'', str.format() y str%() en Python (2):
https://blog.csdn.net/thefg/article/details/130941724