В Python символы новой строки диктуют, как структурировать, отображать и организовывать текст. Без правильной работы с ними ваш вывод может стать запутанным, что приведет к ошибкам и неожиданному поведению ваших скриптов и приложений.
В этом руководстве мы разберем все, что нужно знать о символах перехода на новую строку (/n) в Python. В частности, вы узнаете, как создавать и контролировать переносы строк, очищать текстовые данные, удаляя символы новой строки, и работать с многострочными строками.
Символ новой строки в Python (его еще называют экранированной последовательностью) — /n. Этот символ используется для вставки разрыва строки в тексте, чтобы отделить одну строчку текста от другой. Рассмотрим простой пример:
print("Hello,\nWorld!")
Вывод будет таким:
Hello, World!
Здесь \n гарантирует, что слово “World!” будет выведено на новой строке. Символы перехода на новую строку широко испольуются внутри строк и операторов print() для форматирования текста.
Управление разрывами строк в тексте
Давайте разберемся, как работать с символами новой строки в строках и операторах print(). Также рассмотрим, как использовать многострочные строки для получения более чистого и организованного текста.
Создание многострочных строк
Python позволяет создавать многострочные строки с помощью тройных кавычек (''' или ”””). Такие строки полезны, когда вам нужно хранить или выводить длинные блоки текста.
Многострочные строки сохраняют разрывы строк в тексте, что упрощает работу с форматированными сообщениями или документацией. Например:
message = """Dear User, Thank you for subscribing to our service. Best regards, The Team"""
При печати эта строка сохранит свой многострочный формат:
Dear User, Thank you for subscribing to our service. Best regards, The Team
Управление символами новой строки
Иногда необходимо удалить символы перехода на новую строку, чтобы очистить текстовые данные, особенно при обработке или анализе пользовательского ввода или содержимого файла.
Метод .strip() удаляет пробельные символы как в начале, так и в конце строки, включая символы новой строки (\n). Например:
text = "Hello, World!\n" clean_text = text.strip() print(repr(clean_text))
'Hello, World!'
Если вам нужно удалить только замыкающие символы новой строки (т.е. крайние справа), используйте .rstrip(). В этом примере .rstrip() удаляет перевод на новую строку в конце, оставляя символы /n в начале нетронутыми.
text = "Hello, World!\n" clean_text = text.rstrip() print(repr(clean_text))
'Hello, World!'
Чтобы удалить начальные символы /n (т.е. крайние слева), используйте .lstrip(). Например:
text = "\nHello, World!" clean_text = text.lstrip() print(repr(clean_text))
'Hello, World!'
Эти методы особенно полезны для очистки данных, считанных из файлов или вводимых пользователем, где могут присутствовать лишние переводы на новую строку. Например:
with open('data.txt', 'r') as file:
lines = file.readlines()
clean_lines = [line.strip() for line in lines]
print(clean_lines) # Prints list of lines with no leading or trailing newlines
Этот фрагмент кода считывает строки из файла и удаляет все лишние символы новой строки из каждой строчки.
Символы новой строки в операциях с файлами
Символы новой строки играют важную роль в файловых операциях. Они влияют на то, как текст записывается в файлы и считывается из них. Если вы разберетесь, как это все работает, ваши данные будут хорошо организованы и доступны на разных платформах.
Запись и чтение файлов
При записи текста в файл мы можем разделять строчки содержимого с помощью символов новой строки для улучшения читаемости и облегчения обработки текста в дальнейшем. В отличие от функции print(), такие методы, как write() или writelines(), не добавляют символы новой строки автоматически, поэтому их необходимо указывать явно. Вот пример записи с использованием символов новой строки:
with open('example.txt', 'w') as file:
file.write("First line\n")
file.write("Second line\n")
file.write("Third line\n")
В результате будет создан файл (example.txt) со следующим содержимым:
First line Second line Third line
При чтении текста из файла символы новой строки помогают различать строчки текста. Такие методы, как readlines(), возвращают каждую строчку текста как строку, включая символ новой строки в конце, что позволяет обрабатывать строчки текста по отдельности.
with open('example.txt', 'r') as file:
lines = file.readlines()
for line in lines:
print(repr(line))
'First line\n' 'Second line\n' 'Third line\n'
Каждая строчка включает символ новой строки в конце. Этот символ может быть обработан при необходимости.
Использование os.linesep для обеспечения кроссплатформенной совместимости
В разных операционных системах используются разные символы новой строки. В UNIX-подобных системах, таких как Linux и macOS, используется \n, а в Windows — \r\n. Чтобы обеспечить последовательную обработку символов новой строки на разных платформах, вы можете использовать os.linesep из модуля os.
Переменная os.linesep предоставляет соответствующие символы новой строки для операционной системы, в которой выполняется ваш код. Использование os.linesep позволяет осуществлять ваши файловые операции в разных системах без ручной настройки символов новой строки. Взгляните:
import os
with open('example_cross_platform.txt', 'w') as file:
file.write(f"First line{os.linesep}")
file.write(f"Second line{os.linesep}")
file.write(f"Third line{os.linesep}")
Этот код использует os.linesep для вставки символов новой строки, соответствующих операционной системе. Это гарантирует, что файл example_cross_platform.txt будет правильно отформатирован, независимо от того, открыт он на Windows или UNIX.
Аналогично, при чтении файлов обработка новых строк с помощью os.linesep обеспечивает корректную обработку переносов строк независимо от операционной системы.
import os
with open('example_cross_platform.txt', 'r') as file:
lines = file.readlines()
for line in lines:
print(repr(line.strip(os.linesep)))
Что нужно учитывать при создании переходов на новую строку
Теперь давайте рассмотрим некоторые из наиболее распространенных ловушек при работе с символами новой строки в Python.
Не забывайте о производительности
Хотя работа с новыми строками может показаться незначительным аспектом программирования на Python, она может сказаться на производительности, особенно в крупных проектах.
Использование \n непосредственно в строках обычно эффективно, но если вы имеете дело с кроссплатформенной совместимостью, os.linesep может добавить накладных расходов.
Наилучшими подходами здесь будут следующие:
- Использование
\nпри работе в средах, где платформа известна и контролируется. - Использование
os.linesepв скриптах и приложениях, предназначенных для кроссплатформенного использования. - Сведение к минимуму ненужных манипуляций со строками. Например, не следует слишком часто использовать
.strip()илиrstrip()в коде, для которого производительность очень важна.
Избегайте распространенных ошибок
Работа с символами новой строки иногда может привести к ошибкам, особенно у новичков в Python. К распространенным проблемам относятся:
- Непреднамеренные разрывы строк. Забыв удалить или проконтролировать символы новой строки, вы можете получить лишние пустые строки в выводе или файлах.
- Пропущенные разрывы строк. Пропуск
\nпри записи в файлы может привести к тому, что текст будет сливаться, а это затруднит его чтение и обработку. - Кроссплатформенные несоответствия. К ним может привести использование
\nв скриптах, которые будут работать на разных операционных системах, без учета совместимости.
Чтобы избежать этих подводных камней, всегда тестируйте свой код в той среде, где он будет использоваться, и помните о том, как управляются символы новой строки.
Заключение
В этом руководстве мы рассмотрели основы использования символов новой строки в строках и операторах print(), а также продвинутые техники, такие как использование os.linesep для кроссплатформенной совместимости.
Перевод статьи “Python New Line: Methods for Code Formatting”.
Last Updated :
10 Apr, 2025
Adding or printing a new line in Python is a very basic and essential operation that can be used to format output or separate the data for better readability. Let’s see the different ways to add/print a new line in Python
Using \n escape character
The \n is a escape character and is the simplest way to insert a new line in Python.
Python
print("Hello\nWorld!")
Explanation: Whenever \n is included in a string, it moves the cursor to the next line, hence adding/printing the rest of the output in a new line.
Using print() function with a new line
Using multiple print() statements to simply print a new line.
Python
print("Hello") print("World")
Explanation: The print() function in Python ends with a new line so we don’t need to do anything to create a new line between print statements.
Adding new lines to Strings
We can concatenate multiple strings by using ‘\n’ between them directly to include new lines.
Python
a = "Hello" + "\n" + "World" print(a)
Explanation: \n moves the cursor to the next line, thus printing whatever’s left in the next line.
Using Triple Quotes
Using triple quotes( ‘ ‘ ‘ or » » «) allows us to include new lines directly in the string without using \n.
Python
a = """Hello World""" print(a)
Explanation: Whenever we enclose a string in triple quotes any line breaks, tabs or spaces within the quotes are preserved as they are.
Using os.linesep for Platform Independence
The os.lineup constant provides us with the newline character that is specific to the operating system.
Python
import os # Add new lines using os.linesep a = "Hello," + os.linesep + "This is a new line." print(a)
Output
Hello, This is a new line.
Explanation: This code uses os.linesep to add a platform-specific newline between the strings «Hello,» and «This is a new line.«, and then prints the concatenated message.
Символ новой строки используется в Python, чтобы отмечать конец одной строки и начало новой. Важно понимать, как использовать его для вывода в консоль и работы с файлами.
В этом материале речь пойдет о следующем:
- Как определять символ новой строки в Python.
- Как использовать символ новой строки в строках и инструкциях вывода.
- Вывод текста без добавления символа новой строки в конце.
Символ новой строки
Символ новой строки в Python выглядит так \n. Он состоит из двух символов:
- Обратной косой черты.
- Символа n (в нижнем регистре).
Если встретили этот символ в строке, то знайте, что он указывает на то, что текущая строка заканчивается здесь, а новая начинается сразу после нее.
>>> print("Hello\nWorld!")
Hello
World!Его же можно использовать в f-строках: print(f"Hello\nWorld!").
Символ новой строки в print
По умолчанию инструкции вывода добавляют символ новой строки «за кулисами» в конце строки. Вот так:
Это поведение описано в документации Python. Значение параметра end встроенной функции print по умолчанию — \n. Именно таким образом символ новой строки добавляется в конце строки.
Вот определение функции:
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)Значением end='\n', поэтому именно этот символ будет добавлен к строке.
Если использовать только одну инструкцию print, то на такое поведение можно и не обратить внимание, потому что будет выведена лишь одна строка. Но если использовать сразу несколько таких инструкций:
print("Hello, World 1!")
print("Hello, World 2!")
print("Hello, World 3!")
print("Hello, World 4!")
Вывод будет разбит на несколько строк, потому что символ \n добавится «за кулисами» в конце каждой строки:
Hello, World 1!
Hello, World 2!
Hello, World 3!
Hello, World 4!Как использовать print без символа новой строки
Изменить поведение по умолчанию можно, изменив значение параметра end в функции print. В этом примере настройки по умолчанию приведут к такому результату:
>>> print("Hello")
>>> print("World")
Hello
World
Но если указать значением end пробел (" "), то этот он будет добавлен в конце строки вместо \n, поэтому вывод отобразится на одной строке:
>>> print("Hello", end=" ")
>>> print("World")
Hello World
Это можно использовать, например, для вывода последовательности значений в одной строке, как здесь:
for i in range(15):
if i < 14:
print(i, end=", ")
else:
print(i)
Вывод будет такой:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14Примечание: условная конструкция нужна, чтобы не добавлять запятую после последнего символа.
Таким же образом можно использовать print для вывода значений итерируемого объекта в одну строку:
data = [1, 2, 3, 4, 5]
for num in range(len(data)):
print(data[num], end=" ")
Вывод:
1 2 3 4 5 Для вывода всех элементов списка списка , лучше использовать join: " ".join([str(i) for i in data])
Символ новой строки в файлах
Символ новой строки можно найти и в файлах, но он «скрыт». Создадим файл с именами. Каждое имя будет на новой строке.
names = ['Petr', 'Dima', 'Artem', 'Ivan']
with open("names.txt", "w") as f:
for name in names[:-1]:
f.write(f"{name}\n")
f.write(names[-1])
Если в текстовом файле есть разделение на несколько строк, то это значит, что в конце предыдущей символ \n. Проверить это можно с помощью функции .readlines():
with open("names.txt", "r") as f:
print(f.readlines())
Вывод:
['Petr\n', 'Dima\n', 'Artem\n', 'Ivan']Так, первые три строки текстового файла заканчиваются символом новой строки \n, которая работает «за кулисами».
Выводы
- Символ новой строки в Python — это
\n. Он используется для обозначения окончания строки текста. - Вывести текст без добавления новой строки можно с помощью параметра
end ="<character>", где<character>— это символ, который дальше будет использоваться для разделения строк.
Использование специфических символов играет ключевую роль при добавлении новой линии в текст. Символ
Также предоставляется возможность применять функции и методы, предоставляемые Python. Например, функция print() с параметрами и методы обработки строк могут быть адаптированы так, чтобы маркировать текст newline в зависимости от задач программы. Для более сложных случаев, особенно при работе с большими объемами текстовых данных, эффективным может быть использование модулей, таких как os или sys, что позволяет учитывать специфику среды, в которой исполняется ваш код.
Управление строками в Python
Управление строками в Python открывает обширные возможности для манипуляции текстовыми данными, обогащая проекты с помощью широкого спектра встроенных функций. Понимание особенностей работы с символами и текстовыми последовательностями позволяет легко решать задачи обработки данных и автоматизации.
Строка в Python – это неизменяемая последовательность символов, что позволяет работать с текстом в более структурированной и предсказуемой форме. Когда требуется создание нового текста, следует использовать различные методы и функции.
- Конкатенация: Для объединения нескольких строк в один текст используют оператор
+. Например,'Hello' + ' ' + 'World'создаёт новую строку'Hello World'. - Повторение: Символы строки можно дублировать, используя оператор умножения
*.'abc' * 3будет'abcabcabc'. - Индексация: Доступ к символам строки осуществляется посредством индексов. Например,
text[0]вернёт первый символ строкиtext. - Срезы: Получение подстроки возможно с помощью оператора срезов.
text[1:4]извлекает символы с первого по третий.
Для более сложных манипуляций со строками, Python предлагает богатый набор методов:
upper()— Преобразует все символы в верхний регистр.'python'.upper()вернёт'PYTHON'.lower()— Переводит все символы в нижний регистр.strip()— Удаляет пробелы и другие указанные символы с начала и конца строки.replace(old, new)— Заменяет все вхождения подстрокиoldнаnew.
С помощью перечисленных методов каждый программист может эффективно управлять текстовыми данными, что является незаменимым навыком в разработке любого уровня сложности. Каждый из них открывает новые горизонты в оптимизации и модернизации обработки символов.
Основы: работа с текстом
Работа с текстовыми данными занимает центральное место в программировании, предоставляя эффективные подходы для обработки и управления символьной информацией. Владея базовыми приемами работы с текстом, можно улучшить читаемость и функциональность программного кода. Рассмотрим ключевые методы и приемы для обработки строк при помощи встроенных возможностей языка.
Для успешной работы с текстом следует учитывать три основных аспекта:
- использование символов new line для оптимизации отображения данных;
- операции конкатенации и разбиения строк;
- управление символами с помощью встроенных методов.
Символ new line, обозначаемый как в языке программирования, служит средством для корректного размещения текста. Включение этого символа в строку позволяет облегчить восприятие данных:
example_text = Первая строка Вторая строка
Механизм конкатенации присоединяет различные текстовые элементы, создавая единую цепочку символов. Это достигается с помощью оператора +:
first_part = Первый second_part = фрагмент complete_text = first_part + second_part
Методы управления текстом предоставляют мощные инструменты для модификации строк. Рассмотрим несколько методов:
strip(), удаляющий лишние пробелы по краям;replace(), заменяющий определенные символы на указанные;split(), разделяющий строку на компоненты по заданному разделителю.
Работая с текстовыми данными, особенно при создании программного кода, важно помнить о значимости символов. Включение их в конструкцию программ повышает гибкость и точность в обработке информации, обеспечивая четкую структуру и ясность кода.
Перенос строки: базовые приёмы
В мире программирования обработка текста зачастую требует добавления новых линий в текстовые данные. Знание ключевых символов и приёмов для создания новых строк может значительно упростить код и повысить его читаемость.
Самый простой способ создания новой линии – использовать символ специального назначения
. Этот символ указывает интерпретатору на необходимость начать строку с нового ряда. Например, следующий код поместит текст на двух различных линиях:
text = Первая линия Вторая линия print(text)
Для случаев, где обработка строки осуществляется в контексте многострочных данных, удобнее использовать тройные кавычки. Это позволяет заключать текстовые данные в многострочный формат:
long_text = Первая линия Вторая линия Третья линия print(long_text)
Важно помнить, что в некоторых системах, таких как Windows, используется другой символ новой линии –
. Хотя в большинстве случаев \em>работа с
достаточна для достижения цели.
Для конкатенации строк с добавлением новых линий также можно использовать функцию join. Она эффективно объединяет элементы последовательности, вставляя между ними заданный символ:
lines = [Первая линия, Вторая линия, Третья линия] text = .join(lines) print(text)
Эти простые приемы обеспечивают гибкое и интуитивное управление строками, превращая вашу работу с текстом в эффективный и простой процесс. Выбор подхода зависит от конкретной задачи и предпочтений программиста.
Методы для добавления переходов
Основной способ для создания новой строки – использование символа новой линии
print(Привет, мир! Добро пожаловать в программирование!)
Для многострочных строковых значений в Python применяют тройные кавычки. Они позволяют создавать строки в несколько строк без необходимости явно указывать символ новой линии:
текст = Первое предложение Второе предложение Третье предложение
Если требуется добавить новый элемент в структуру данных, например, список, с разрывами строк, можно использовать цикл с добавлением
к каждому элементу:
lines = [Первая линия, Вторая линия, Третья линия] новый_текст = .join(lines) print(новый_текст)
Такой подход помогает быстро и эффективно создавать текст со вставленными переходами, используя встроенные возможности языка и минимальное количество символов. Оптимальное использование данных методов способствует написанию кода, легкого для восприятия и обслуживания. Это важно при разработке сложных приложений, включающих обширную работу с текстом.
Специальные символы: использование
Специальные символы открывают возможности более детального контроля над строковыми данными. Например, символ
не является единственным средством для создания новой линии. В мире программирования существуют и другие символы, которые могут помочь в управлении текстом. Один из таких символов – \t, который добавляет табуляцию, создавая удобные отступы в тексте.
Существует еще одна категория специальных символов – управляющие символы, которые изменяют поведение программы. К примеру, комбинации
для возврата каретки и \b для удаления предыдущего символа. Эти символы пригодятся в ситуациях, когда требуется более сложный контроль текста внутри кода.
Ввод уникальных символов и их использование enhances your programming capabilities, allowing for highly flexible data preparation and presentation. Understanding and mastering these tools is essential for those who seek to deepen their understanding of text manipulation.
Как внедрить перенос строки в код
Одним из часто используемых методов организации текста является вставка специального символа. В языке программирования можно использовать комбинации, которые автоматически переходят на новую строку. Например, символ встраивается в строки для указания разграничения, что особенно полезно при создании длинных блоков текста или генерации отчетов. Рассмотрим простой пример:
text = Привет, мир! Добро пожаловать в программирование! print(text)
В дополнение к , можно использовать другие способы, такие как метод join(), который объединяет элементы и позволяет контролировать разрывы. Вот пример использования:
lines = [Строка 1, Строка 2, Строка 3] result = .join(lines) print(result)
Функции Python для строк
Эффективное манипулирование текстовыми данными в Python требует понимания встроенных функций для работы со строками. Эти инструменты позволяют программировать автоматизированное редактирование текста, изменять структуру строк и выполнять множество других операций. Рассмотрим их различное применение и узнаем, как эти функции могут улучшить обработку текста в вашем коде.
Строковые функции в Python дают возможность изменять и форматировать текст. Они позволяют преобразовать регистры букв, удалять лишние пробелы, находить необходимые символы или подстроки и многое другое. Изучение этих возможностей может значительно упростить обработку текстовых данных.
Ниже представлена таблица с описанием популярных строковых функций и их краткое объяснение:
| Функция | Описание |
|---|---|
len() |
Возвращает длину строки. |
upper() |
Преобразует строку в верхний регистр. |
lower() |
Преобразует строку в нижний регистр. |
strip() |
Удаляет пробелы из начала и конца строки. |
replace() |
Замещает указанные подстроки в строке на новые значения. |
find() |
Возвращает индекс первого вхождения указанного символа или подстроки. Если ничего не найдено, возвращает -1. |
split() |
Делит строку на части по заданному разделителю и возвращает список. |
join() |
Объединяет элементы из списка в одну строку с использованием указанного разделителя. |
Пример использования функций:
text = Hello, world! modified_text = text.strip().upper()
Функции для работы со строками делают код читаемым и компактным. Они избавляют от необходимости создавать сложные алгоритмы для простых операций и делают обработку текстовых данных эффективной и понятной. Используйте эти инструменты, чтобы ваши программы были более гибкими и продуктивными.
Инструменты для удобного форматирования
Форматирование текста играет важную роль при работе с кодом. Для эффективной работы необходимо задействовать инструменты, которые помогут структурировать текст в новых строках и интегрировать изменения без лишней траты времени.
Одним из таких инструментов является текстовый редактор с поддержкой работы с кодом. Многие редакторы позволяют настроить автоматическое добавление новых строк. Например, такие редакторы, как Visual Studio Code или PyCharm, могут настроить подсветку синтаксиса и автоматическое добавление отступов при переносе частей line кода.
Использование стандартных библиотек языка — еще один ключевой инструмент. Модуль textwrap в Python позволяет разбивать длинные строки на несколько новых наборов символов, обеспечивая удобочитаемость. Например, можно легко управлять длиной строк следующим образом:
import textwrap example_text = Это пример очень длинного текста, который требуется разделить на несколько более коротких строк. wrapped_text = textwrap.fill(example_text, width=50) print(wrapped_text)
Многие IDE поддерживают плагины и расширения, которые автоматизируют форматирование. Эти инструменты анализируют code и автоматически применяют правила форматирования. Например, использование утилиты black для Python помогает поддерживать единый стиль написания, включая автоматическое добавление отступов и разбиение длинных line.
Наконец, системы контроля версий, такие как Git, позволяют отслеживать изменения в коде. Это помогает управлять текстом и внедрять новый формат с учетом исторических изменений, сохраняя структуру данных.
Комментарии
| Введение | |
| Пример | |
| Перенос f-string | |
| Перенос при присваивании | |
| Объявление функции | |
| if | |
| Объявление списка | |
| Перенос при импорте | |
| Похожие статьи |
Введение
Если
строка
превышает 80 символов в длину — по PEP 8 её нужно разделить на несколько.
Пример
Пример слишком длинной строки
url = your_base_url + «/monitor-service/api/v1/components/744618a0-78c5-4e19-78f4-6d215bde64a5»
Чтобы сделать перенос строки — воспользуйтесь символом \
url = your_base_url + \
«/monitor-service/api/v1/components/744618a0-78c5-4e19-78f4-6d215bde64a5»
Или
url = your_base_url + «/monitor-service/api/v1/components/» \
«744618a0-78c5-4e19-78f4-6d215bde64a5»
f-string
Если нужно перенести
f-string
,
например:
print(f’\n\nPOST to {your_url} response status code is {response.status_code}\n‘)
Новую строку тоже нужно начать с f
print(f’\n\nPOST to {your_url} response status code is ‘
f’{response.status_code}\n‘)
Если после переноса оказывается, что в какой-то строке не осталось переменных — у неё не нужно писать f
url: str = «https://testsetup.ru»
print(«Адрес моего сайта о тестировании ПО:»
f«{url} содержит https,»
«переходите по ссылке.»)
Если длинная f-string используется при объвлении переменной — при переносе нужно взять её в скобки
current_time = time.strftime(«%Y-%m-%d-%H-%M-%S»)
epoch_time = int(time.time())
url = «https://testsetup.ru»
message = (f«В данный момент: {current_time}«
f«linux epoch time: {epoch_time}«
f«{url} содержит https, переходите по ссылке«)
Примеры переноса текста с f-string которые дают одинаковый результат
d = «.ru»
s1 = «My website about software testing: testsetup» + \
f«{d} and my website about travel: heihei{d}«
s2 = («My website about software testing: testsetup» +
f«{d} and my website about travel: heihei{d}«)
s3 = («My website about software testing: testsetup»
f«{d} and my website about travel: heihei{d}«)
s4 = (f«My website about software testing: testsetup\
{d} and my website about travel: heihei{d}«)
print(«\n», s1, «\n», s2, «\n», s3, «\n», s4)
My website about software testing: testsetup.ru and my website about travel: heihei.ru
My website about software testing: testsetup.ru and my website about travel: heihei.ru
My website about software testing: testsetup.ru and my website about travel: heihei.ru
My website about software testing: testsetup.ru and my website about travel: heihei.ru
Перенос при присваивании
Если нужно перенести выражение вида a = b, где b это что-то длинное:
# Правильно:
# Выравнивание по открывающей скобке.
foo = long_function_name(var_one, var_two,
var_three, var_four)
# Второй вариант так называемый «Подвешенный» отступ.
foo = long_function_name(
var_one, var_two,
var_three, var_four)
# Если поставить запятую в конце — закрывающую скобку можно.
# поместить под первым непустым символом.
result = some_function_that_takes_arguments(
‘a’, ‘b’, ‘c’,
‘d’, ‘e’, ‘f’,
)
# Либо в начало строки.
result = some_function_that_takes_arguments(
‘a’, ‘b’, ‘c’,
‘d’, ‘e’, ‘f’,
)
# Неправильно:
# Запрещено перечислять аргументы в первой строке
# если следующая не выровнена.
foo = long_function_name(var_one, var_two,
var_three, var_four)
Объявление функций
Если нужно объявить функцию с большим числом параметров:
# Правильно:
# Нужно отступить на 4 пробела, чтобы выделить параметры.
def long_function_name(
var_one, var_two, var_three,
var_four):
print(var_one)
# Неправильно
# Параметры не выделяются и читать неудобно
def long_function_name(
var_one, var_two, var_three,
var_four):
print(var_one)
if
Ветвления на основе if разрешено оформлять следующими способами:
# Без отступа.
if (this_is_one_thing and
that_is_another_thing):
do_something()
# Хороший приём — добавить комментарий, который улучшит читаемость
# в редакторах с подсветкой синтаксиса.
if (this_is_one_thing and
that_is_another_thing):
# Since both conditions are true, we can frobnicate.
do_something()
# Разрешено добавить отступ перед and.
if (this_is_one_thing
and that_is_another_thing):
do_something()
Объявление списков
Списки можно объявлять двумя способами:
my_list = [
1, 2, 3,
4, 5, 6,
]
my_list = [
1, 2, 3,
4, 5, 6,
]
Перенос при импорте
Если нужно делать перенос при импорте модулей, нужно заключить названия модулей в скобки
from devhopspac import (first_long_function_name,
second_long_function_name)
Автор статьи: Андрей Олегович
Похожие статьи
| C | |
| C++ | |
| Go | |
| Groovy | |
| Java | |
| JavaScript | |
| PHP | |
| Python | |
| Ruby | |
| .NET/C# | |
| Thrift | |
| Теория Программирования | |
| f-string |