python - suma - Literal de cadena con comillas triples en definiciones de funciones

secuencias de escape python

Question

Estoy siguiendo el tutorial de Python y en algún momento hablan de cómo la primera declaración de una función puede ser un Literal de cadena. En lo que respecta al ejemplo, este Literal de cadena parece estar hecho con tres, dando en el example

"""Print a Fibonacci series up to n."""

De acuerdo con esta documentación, esto se usaría principalmente para crear algún tipo de documentación producida automáticamente.

Entonces, me pregunto si alguien aquí podría explicarme cuáles son exactamente estos literales de cuerda.

Answer 1

Bueno, puede ser útil echar un vistazo a los conceptos de expresiones, literales y cadenas.

Cadenas, expresiones y literales

En un programa, tenemos que representar varios tipos de datos. Un tipo de datos son números enteros; otro tipo son números de pinta flotantes. Un tipo muy importante de datos es texto, una secuencia de letras, números y otros caracteres. Este tipo generalmente se llama cadena .

Un valor de algún tipo puede ser producido de varias maneras. Por ejemplo, la expresión de Python a continuación produce el valor 4 y lo pone en una variable. El valor fue cedido por la expresión 2+2 :

i = 2+2

Dada la expresión anterior, la expresión siguiente produce el mismo valor 4, pero ahora esta expresión contiene solo una variable :

i

A continuación, generé un valor por una expresión y lo recuperé mediante una variable .

Los idiomas, sin embargo, deben proporcionar una sintaxis para generar valores básicos directamente. Por ejemplo, el 2 en la expresión anterior recupera el valor 2. Aquellas expresiones que producen valores básicos directamente se llaman literales . Ambas expresiones 2+2 y 4 producen el mismo valor, 4, pero la segunda expresión lo produce directamente, si sabes a qué me refiero, entonces es un literal.

Literales de cadenas y cadenas multilínea

Un literal de cadena , de esta manera, es un literal que produce una cadena. En Python, esos literales están marcados de muchas maneras. Dos formas son poner una comilla simple o doble al principio o al final del literal:

"A string literal"

''Another string literal''

Otras formas son poner tres comillas simples o dobles en las mismas posiciones. En este caso, el literall puede abarcar a través de líneas múltiples:

"""A single line string literal"""

"""A multiline
string literal"""

''''''Another multiline
string literal''''''

Tenga en cuenta que el método de generar una cadena literal no cambia su valor. Una cadena de una sola cita es igual a una cadena de doble cita con los mismos caracteres, y una cadena de tres cita es igual a una cadena de una cita con el mismo contenido:

"A single line string literal" == ''A single line string literal''

"""A single line string literal""" == "A single line string literal"

"A multiline/nstring literal" == """A multiline
string literal""" # /n is the character that represents a new line

Docstrings y por qué deberían ser literales de cadenas

Lo que la documentación está diciendo es que puede poner una cadena literal justo después de la declaración del método y este literal se usará como documentación: lo que usamos para llamar a una cadena de documentos . No importa si utiliza cadenas de comillas simples o dobles, o cadenas de cita de uno o tres. Considere las funciones a continuación:

def f1(value):
    "Doc for f1"
    return value + 1

def f2(value):
    """Doc for f2"""
    return value + 2

Ahora, declare en su consola de python y llame a help(f1) y help(f2) . Tenga en cuenta que la declaración de la cadena no importa. OTOH, no puede usar otras expresiones, como variables u operaciones sobre cadenas, para generar su documentación. Entonces las cadenas en la primera línea de las funciones a continuación no son docstring :

mydoc = "This is doc"
def f3(value):
     mydoc
     return value+3

 def f4(value):
     "This is no documentation " + "because it is concatenated"
     return value+4

Debe ser literal porque el compilador está preparado para administrarlo como documentación. Sin embargo, el compilador no está preparado para gestionar variables, expresiones complejas, etc. como documentación, por lo que los ignorará.

¿Por qué utilizar cadenas de comillas triples como cadenas de documentos?

Aunque cualquier forma de literal de cadena se puede usar en documentos, puede considerar que la documentación generalmente incluye textos muy largos, con varias líneas y párrafos. Bueno, dado que incluye varias líneas, se recomienda utilizar las formas literales que aceptan varias líneas, ¿verdad? Esta es la razón por la cual las cadenas de comillas triples son la forma preferida (pero no obligatoria) de escribir cadenas de documentos.

Una nota marginal

En realidad, puedes poner una cadena literal en cualquier lugar de una función de Python:

 def flying_literals(param):
    "Oh, see, a string literal!"
    param += 2
    "Oh, see, ANOTHER string literal!"
    return param
    "the above literal is irrelevant, but this one can be still MORE IRRELEVANT"

Sin embargo, solo la literal a la primera línea hace alguna diferencia (siendo la documentación). Los otros son como operaciones no operativas.

Answer 2

De lo que estás hablando (creo) se llaman docstrings (gracias Boud por el enlace).

def foo():
    """This function does absolutely nothing"""

Ahora, si escribe help(foo) del intérprete, verá la cadena que puse en la función. También puede acceder a esa cadena por foo.__doc__

Por supuesto, los literales de cadena son solo eso: cadenas literales.

a = "This is a string literal"  #the string on the right side is a string literal, "a" is a string variable.

o

foo("I''m passing this string literal to a function")

Se pueden definir de varias maneras:

''single quotes''
"double quotes"
""" triple-double quotes """  #This can contain line breaks!

o incluso

#This can contain line breaks too!  See?
'''''' triple-single 
    quotes ''''''

Answer 3

En python hay varias formas de dividir cadenas en múltiples líneas. Literales de cadenas es uno de ellos, por ejemplo:

s = """Hello, 
    world"""
print(s)
>>> Hello, 
>>>     world #Notice, that spaces used in the literal are kept. 

Pero como notó correctamente, los literales de cadena generalmente están ahí para la documentación en línea

class MyClass(object):
    """This is my class it does this and that.

       It has some cool features and I may tell you about them below.
    """

    def my_method(self):
        """This is a brief description of my method."""

    def important_method(self):
        """Because this method is important, I''m going to tell you 
           a lot about it. For example...
        """

Antes de preguntar, una buena manera de dividir cadenas en múltiples líneas, son los paréntesis sagrados de Python:

s = (''This is a very very long string. ''
     ''I have to split it to multiple lines. ''
     ''Whoa! It works!'')   
print(s)
>>> This is a very very long string. I have to split it to multiple lines. Whoa! It works!

Es posible que necesite esto para seguir el PEP-8, que establece que "No debe exceder los 80 caracteres por línea".

¡Feliz hackeo de Python!

Answer 4

Son cadenas como cualquier otra cadena con pares de '' , " , '''''' o """ alrededor.
La forma recomendada es la comilla doble triple:

def some_function(s):
    """this is documentation for some_function"""
    print(s)

Answer 5

Un literal de cadena es simplemente una cadena dada literalmente en el código fuente. No importa si se trata de una docstring u otra cadena. Consulte la sección de documentación del lenguaje de Python en los literales de cadenas para obtener todos los detalles, pero es probable que no necesite estos detalles ahora.

Algunos ejemplos:

"abc"
''Guido''
r"""Norwegian Blue"""

Answer 6

Un literal de cadena es una cadena en una de las muchas opciones de cotización, que no está asignada a una variable.

Asi que,

"String" # string literal
''string'' # string literal
"""
  Multiline
  String
  Literal
"""
foo = "string variable"

Cuando tiene un literal de cadena inmediatamente después de un bloque de def , se convierte en parte de la documentación para ese método y se denomina docstring.

def foo(hello):
    """This is part of the documentation for foo"""

Así es como lo usarías:

>>> def foo(hello):
...     """This is the docstring"""
...     pass
... 
>>> foo.__doc__
''This is the docstring''