Ответ 1

То, о чем вы говорите (я думаю), называется строкой документации (спасибо Боуду за ссылку).

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

Теперь, если вы введете help(foo) из интерпретатора, вы увидите строку, которую я поместил в функцию. Вы также можете получить доступ к этой строке с помощью foo.__doc__

Конечно, строковые литералы - это просто литеральные строки.

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

или же

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

Их можно определить несколькими способами:

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

или даже

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

Ответ 2

Что ж, может быть полезно взглянуть на понятия выражений, литералов и строк.

Строки, выражения и литералы

В программе мы должны представлять различные типы данных. Одним типом данных являются целые числа; другой тип - числа с плавающей запятой.

Значение некоторого типа может быть получено различными способами, т.е. С помощью различных выражений. Выражение - это любой фрагмент программы, который "создает" значение. Например, приведенное ниже выражение Python возвращает значение 4 и помещает его в переменную. Значение получено выражением 2+2:

i = 2+2

Учитывая приведенное выше утверждение, приведенное ниже выражение дает то же значение 4, но теперь это выражение содержит только переменную:

i

Ниже я сгенерировал значение с помощью арифметического выражения и извлек его с помощью переменной (которая также является выражением).

Однако языки должны обеспечивать синтаксис для непосредственного получения базовых значений. Например, 2 в вышеприведенном выражении возвращает значение 2. Те выражения, которые напрямую выдают базовые значения, называются литералами. Оба выражения 2+2 и 4 дают одно и то же значение 4, но второе выражение возвращает его напрямую, поэтому оно является литералом.

Строковые литералы и многострочные строки

Очень важным типом данных является текст, последовательность букв, цифр и других символов. Этот тип обычно называется строкой.

Строковый литерал, таким образом, является литералом, который дает строку. В Python эти литералы помечаются разными способами (т.е. Существует множество синтаксисов для строковых литералов). Например, вы можете поставить одинарную или двойную кавычку в начале или конце литерала:

"A string literal"

'Another string literal'

Другими способами являются размещение трех одинарных или двойных кавычек в одинаковых позициях. В этом случае литерал может занимать несколько строк:

"""A single line string literal"""

"""A multiline
string literal"""

'''Another multiline
string literal'''

Обратите внимание, что какой бы синтаксис вы ни выбрали для строкового литерала, он не меняет своего значения. Строка в кавычках single- равна строке в двойных кавычках с теми же символами, а строка в трех кавычках равна строке в кавычках one- с таким же содержанием:

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

>>> """A single line string literal""" == "A single line string literal"
True

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

Строки документов и почему они должны быть строковыми литералами

Документация говорит, что вы можете поместить строковый литерал сразу после объявления метода, и этот литерал будет использоваться в качестве документации - то, что мы используем для вызова строки документации. Не имеет значения, используете ли вы single- или строки в двойных кавычках, или one-, или строки из трех кавычек: это просто должен быть литерал.

Рассмотрим функции ниже:

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

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

Теперь объявите их в консоли Python и вызовите help(f1) и help(f2). Обратите внимание, что синтаксис строкового литерала не имеет значения.

OTOH, вы не можете использовать другие выражения, такие как переменные или операции над строками, для генерации вашей документации. Поэтому строки в первой строке функций ниже не являются строкой документации:

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

Это должен быть литерал, потому что компилятор был написан явно для управления им как документацией. Однако компилятор не подготовлен для управления переменными, сложными выражениями и т.д. В качестве документации, поэтому он будет игнорировать их. Другими словами, это дизайн.

Зачем использовать строки с тройными кавычками в качестве строк документации?

Хотя в строковых документах может использоваться любая форма строкового литерала, вы можете подумать, что документация обычно содержит очень длинные тексты с несколькими строками и абзацами. Ну, так как он включает в себя много строк, лучше использовать буквенные формы, которые принимают несколько строк, верно? По этой причине строки с тройными кавычками являются предпочтительным (но не обязательным) способом написания строк документации.

Заметка на полях

На самом деле, вы можете поместить строковый литерал в любое место функции 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"

Тем не менее, только литерал в первой строке имеет значение (будучи документацией). Другие, как никакие операции операции.

Ответ 3

Строковый литерал - это просто строка, введенная буквально в исходном коде. Является ли это докстером или другой строкой, не имеет значения. См. раздел документации по языку Python для строковых литералов для всех деталей, но вам, вероятно, сейчас не нужны эти данные.

Несколько примеров:

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

Ответ 4

Строковый литерал - это строка в одной из многих опций кавычек, которая не назначается переменной.

Итак,

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

Когда у вас есть строковый литерал сразу после блока def, он становится частью документации для этого метода и называется docstring

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

Вот как вы его используете:

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

Ответ 5

В Python есть несколько способов разделить строки на несколько строк. Строковые литералы - это один из них, например:

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

Но, как вы правильно заметили, строковые литералы обычно присутствуют для встроенной документации

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...
        """

Прежде чем вы спросите, хороший способ разбить строки на несколько строк, это святая скобка 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!

Вам может понадобиться это, чтобы следовать PEP-8, в котором говорится, что "Вы не должны превышать 80 символов в строке".

Счастливого взлома Python!

Ответ 6

Они представляют собой строки, подобные любым другим строкам с парами ', ", ''' или """ вокруг них.
Рекомендуемая форма - тройная двойная кавычка:

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