В чем смысл этого утверждения Python?

Question

Более конкретно, я не уверен, что и символы «%» «\», приезжающие сразу после друг друга, как предполагается, означает:

return 'guitar { id: %d, relevant_properties: (%.02f, %.02f, %.02f), irrelevant_properties: (%.02f, %.02f, %.02f) }' % \ 
    (self.id, a, b, c, d, e, f) 

Является ли это возвращение заявление считается один строка кода ? Потому что я изначально думал, что «\» был там, чтобы нарезать то, что кажется чересчур длинной линией на две части, чтобы повысить удобочитаемость и избежать обертывания.

Кроме того, я в таблице здесь отражает то, что в моем коде. Часть, которая гласит '(self.id, a, b, c, d, e, f)', действительно имеет вкладку еще раз, чем начало оператора return.

В принципе, это утверждение эквивалентно:

return 'guitar { id: %d, relevant_properties: (%.02f, %.02f, %.02f), irrelevant_properties: (%.02f, %.02f, %.02f) }' % (self.id, a, b, c, d, e, f) 

в этом, нет «\» участвует ....

Answer 1

% символ известен как строки форматирования или интерполяции строк оператора и описан в String Formatting Operations. Также обратите внимание, что в моих примерах я переместил символ % на следующую строку, а не оставил его в конце предыдущей строки. Обе формы действительны, однако они помещаются в ту же линию, что и данные, используемые для интерполяции, как правило, упрощают чтение и упрощают обслуживание.

Да, эти две части кода эквивалентны, поскольку обратная косая черта относится к двум или более физическим линиям как к одной логической строке, как описано в документации Python о знаке \ в разделе о Explicit Line Joining.Однако я бы не использовать явную линию, соединяющую и вместо того, чтобы использовать этот третий эквивалентный путь под названием Implicit Line Joining:

return ('guitar { id: %d, relevant_properties: (%.02f, %.02f, %.02f), irrelevant_properties: (%.02f, %.02f, %.02f) }' 
     % (self.id, a, b, c, d, e, f)) 

Потому что он менее подвержен ошибкам при переформатировании, а также позволяет использовать комментарии, например, в этом отформатированного Например:

return ('guitar { id: %d, relevant_properties: (%.02f, %.02f, %.02f), irrelevant_properties: (%.02f, %.02f, %.02f) }' 
     % (self.id, 
      a, 
      b, 
      # c1, 
      c2, 
      d, 
      e, 
      f)) 

Попробуйте сделать то же самое с обратной косой чертой ... не только более трудным, но вы также не можете использовать комментарии.

Обратите внимание, что круглые скобки вокруг возвращаемого значения не являются излишними, как некоторые предложили; они, что позволяет использовать implicit line joining в контексте переменной интерполяции (которая отделена от кортежа после %, который является дополнительным контекст, в котором неявная линии, соединяющая также бывает):

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

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

Связанный объект с явным/неявным соединением линий - это использование трехцилиндровых строк, рассмотренных в разделе String Literals. Учитывая C-стиль блок синтаксиса вашего примера гитары, я ожидаю, что это, вероятно, будет действительным переформатировать возвращаемое значение в нескольких строк, как это:

class c(object): 
    def f(self): 
     return """ 
guitar { 
    id: %d, 
    relevant_properties: (%.02f, %.02f, %.02f), 
    irrelevant_properties: (%.02f, %.02f, %.02f) 
} 
""" % (self.id, a, b, c, d, e, f) 

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

Помните, однако, что форматирование выше может привести к нежелательным переходящим или завершающим символам новой строки, так что это один из немногих случаев, когда я иногда рекомендую использовать явное соединение строк.Причина здесь заключается в том, чтобы устранить ненужные дополнительные символы новой строки в качестве компромисса для улучшенной читаемости кода, которую дают трикотабельные строки, поскольку это позволяет нам видеть полную строфу более или менее так, как мы увидим ее в конечном выпуске ; Сравнение выше, вы будете видеть только добавление одного \ символа в конце первого появления """:

class c(object): 
    def f(self): 
     return """\ 
guitar { 
    id: %d, 
    relevant_properties: (%.02f, %.02f, %.02f), 
    irrelevant_properties: (%.02f, %.02f, %.02f) 
} 
""" % (self.id, a, b, c, d, e, f) 

Answer 2

Да, \ в конце строки экранирует символ новой строки поэтому эти два фрагмента кода эквивалентны.

Он описан здесь: http://docs.python.org/reference/lexical_analysis.html#explicit-line-joining

Answer 3

Да, что у вас есть есть простой формат строки разбиты на две строки. Оператор обратной косой черты просто позволяет вам разбить операторы python на несколько строк (поскольку Python является чувствительным к пробелу).

Answer 4

Символ обратной косой черты делает python игнорировать новую строку в конце первой строки (см. the docs). Так что да, ваши две части кода действительно эквивалентны.

Answer 5

Поскольку я изначально считал, что «\» был там, чтобы нарезать то, что кажется чересчур длинной, на две части, чтобы улучшить читаемость и избежать обертывания.

Это. Что вы считаете непонятным?

После того, как линия объединена, вы просто получите длинную строку, за которой следует %, за которой следует кортеж. Это имеет обычный смысл; % используется для строковой интерполяции.

Answer 6

В сценарии, открытое с IDLE, я получил следующее углубление в теле следующей функции в :

def f(self, a, b, c, d, e, f): 
    return 'guitar { id: %d, relevant_properties: (%.02f, %.02f, %.02f), irrelevant_properties: (%.02f, %.02f, %.02f) }' % \ 
      (self.id, a, b, c, d, e, f) 

Чтобы получить этот отступ, поместите курсор между (%.02f, %.02f, %.02f) }' % \ и (self.id, a, b, c, d, e, f), а затем нажмите на кнопку ENTER

Если я копирую, здесь на SO, только два л Инес из тела Вышеуказанная функция, без нажатия на {} кнопку, я получаю:

return 'guitar { id: %d, relevant_properties: (%.02f, %.02f, %.02f), irrelevant_properties: (%.02f, %.02f, %.02f) }' % \ 
     (self.id, a, b, c, d, e, f) 

Углубление в ответ aculich является правильным, и один ваш вопрос не совсем неправильно (потому что ваш код будет работать без ошибок), но не визуально приятным.

.

Лично я считаю, что предпочтительнее поставить операционную Подписать % на линии следующих \, а не перед ним, как это:

return 'guitar { id: %d, relevant_properties: (%.02f, %.02f, %.02f), irrelevant_properties: (%.02f, %.02f, %.02f) }'\ 
     % (self.id, a, b, c, d, e, f) 

.

можно улучшить отображение, так что ширина уменьшается, как это:

return ('guitar ' 
     '{ ' 
     'id: %d, ' 
     'relevant_properties: (%.02f, %.02f, %.02f), ' 
     'irrelevant_properties: (%.02f, %.02f, %.02f) ' 
     '}') \ 
     % (self.id, a, b, c, d, e, f) 

Bouaif (это личное французского звукоподражание пытается выразить сомнение), это не фантастическое, потому что он смешивает неявную и явную линию, соединяющую ,

EDIT: Затем, принимая во внимание объяснения aculich, тем выше уменьшенной ширины раствора можно записать также

return ('guitar ' 
     '{ ' 
     'id: %d, ' 
     'relevant_properties: (%.02f, %.02f, %.02f), ' 
     'irrelevant_properties: (%.02f, %.02f, %.02f) ' 
     '}' 
     % (self.id, a, b, c, d, e, f)) 

Ну, что получил больше стиля.

Но я не решаюсь, зная, какой из них я предпочитаю среди этому последнему и следующим образом , что пришло мне в голову, думая обо всем, что:

return ('guitar ' 
     '{ ' 
     'id: %d, ' 
     'relevant_properties: (%.02f, %.02f, %.02f), ' 
     'irrelevant_properties: (%.02f, %.02f, %.02f) ' 
     '}' 
     ) % (self.id, a, b, c, d, e, f)