Programing

함수 정의에 삼중 따옴표가있는 문자열 리터럴

즐거운 cyworld 2021. 1. 11. 07:30
반응형

함수 정의에 삼중 따옴표가있는 문자열 리터럴


저는 Python 튜토리얼을 따르고 있으며 어느 시점에서 함수의 첫 번째 문이 어떻게 String Literal이 될 수 있는지에 대해 이야기합니다. 예가는까지로,이 문자열 리터럴 세와 함께 할 것 "에서 제공의

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

이 문서에 따르면 이것은 주로 일종의 자동 생성 문서를 만드는 데 사용됩니다.

그래서 여기 누군가가이 문자열 리터럴이 정확히 무엇인지 설명해 줄 수 있는지 궁금합니다.


당신이 (내가 생각하는)에 대해 얘기라고 문서화 문자열 (감사합니다 링크에 대한 Boud).

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 '''

글쎄, 표현, 리터럴 및 문자열의 개념을 살펴 보는 것이 도움이 될 수 있습니다.

문자열, 표현식 및 리터럴

프로그램에서 우리는 다양한 유형 의 데이터 를 표현해야합니다 . 데이터 유형 중 하나 는 정수입니다. 다른 유형은 부동 소수점 숫자입니다.

어떤 유형의 값은 다양한 방식, 즉 다양한 표현을 통해 산출 될 수 있습니다 . 표현은 값을 "생성"하는 프로그램의 코드 조각입니다. 예를 들어 아래의 Python 표현식은 값 4를 산출하여 변수에 넣습니다. 값은 다음 으로 산출되었습니다 2+2.

i = 2+2

위의 문이 주어지면 아래 표현식 은 동일한 값 4를 산출하지만 이제이 표현식에는 변수 만 포함됩니다 .

i

아래에서는 산술 표현식 으로 값을 생성하고 변수 (표현식이기도 함)로 검색했습니다 .

그러나 언어는 기본 값을 직접 생성하는 구문을 제공해야합니다. 예를 들어, 2위의 식에서는 값 2를 검색합니다. 기본 값을 직접 생성하는 식을 리터럴 이라고 합니다. 두 표현 2+24동일한 값, (4)을 수득하지만, 제 발현 수율 직접적 때문에 리터럴이다.

문자열 리터럴 및 여러 줄 문자열

매우 중요한 데이터 유형은 텍스트, 일련의 문자, 숫자 및 기타 문자입니다. 이 유형을 일반적으로 string 이라고 합니다 .

문자열 리터럴은 이러한 방식으로, 문자열을 산출 리터럴입니다. 파이썬에서 이러한 리터럴은 여러 방법으로 표시됩니다 (즉, 문자열 리터럴에 대한 많은 구문이 있습니다). 예를 들어 리터럴의 시작 또는 끝에 작은 따옴표 나 큰 따옴표를 넣을 수 있습니다.

"A string literal"

'Another string literal'

다른 방법은 같은 위치에 세 개의 작은 따옴표 또는 큰 따옴표를 넣는 것입니다. 이 경우 리터럴은 여러 줄에 걸쳐있을 수 있습니다.

"""A single line string literal"""

"""A multiline
string literal"""

'''Another multiline
string literal'''

문자열 리터럴에 대해 어떤 구문을 선택하든 그 값은 변경되지 않습니다. 작은 따옴표로 묶인 문자열은 같은 문자를 가진 큰 따옴표로 묶인 문자열과 같고, 세 개의 따옴표로 묶인 문자열은 같은 내용을 가진 작은 따옴표 문자열과 같습니다.

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

독 스트링과 문자열 리터럴이어야하는 이유

문서가 말하는 것은 메서드 선언 바로 뒤에 문자열 리터럴을 넣을 수 있으며이 리터럴은 문서로 사용된다는 것 입니다. docstring 을 호출하는 데 사용합니다 . 작은 따옴표 또는 큰 따옴표 문자열을 사용하는지 또는 한 따옴표 또는 세 따옴표 문자열을 사용하는지는 중요하지 않습니다. 단지 리터럴 이어야합니다 .

아래 기능을 고려하십시오.

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

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

이제 파이썬 콘솔에서 선언하고 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

It should be a literal because the compiler was written explicitly to manage it as documentation. However, the compiler is not prepared to manage variables, complex expressions etc. as documentation, so it will ignore them. In other words, it is by design.

Why use triple quote strings as docstrings?

Although any form of string literal can be used in docstrings, you may consider that documentation usually includes very long texts, with multiple lines and paragraphs. Well, since it includes many lines, better to use the literal forms which accept multiple lines, right? This is the reason why triple-quote strings are the preferred (but not mandatory) way of writing docstrings.

A marginal note

Actually, you can put a string literal in any place of a Python function:

 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"

However, only the literal in the first line makes some difference (being the documentation). The other ones are like no operation operations.


A string literal is simply a string given literally in the source code. Whether it is a docstring or another string does not matter. See the Python language documentation section on string literals for all the details, but you probably don't need these details now.

A few examples:

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

A string literal is a string in one of the many quoting options, that is not assigned to a variable.

So,

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

When you have a string literal immediately after a def block, it becomes part of the documentation for that method, and is called a docstring

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

This is how you would use it:

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

In Python there are several ways to divide strings into multiple lines. Strings literals is one of them, for example:

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

But as you noticed correctly, string literals are usually there for the in-line documentation

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

Before you ask, a good way to split strings on multiple lines, are the holy Python parenthesis:

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!

You may need this to follow the PEP-8, which states that "Thou shalt not exceed 80 characters per line".

Happy Python hacking!


They are strings like any other strings with pairs of ', ", ''' or """ around them.
The recommended form is the triple double quote:

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

ReferenceURL : https://stackoverflow.com/questions/10840357/string-literal-with-triple-quotes-in-function-definitions

반응형