Перенос строки питон: Перенос длинного кода на новую строку Python

Содержание

Перенос длинного кода на новую строку Python

Содержание
	Введение
	Пример
	Перенос 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')

Перенос при присваивании

Если нужно перенести выражение вида 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, ]

Похожие статьи
	Python
	Интерактивный режим
	str: строки
	Списки []
	if, elif, else
	Циклы
	Функции
	try except
	Пакеты
	*args **kwargs
	ООП
	enum
	Опеределить тип переменной Python
	Тестирование с помощью Python
	Работа с REST API на Python
	Файлы: записать, прочитать, дописать, контекстный менеджер…
	Скачать файл по сети
	SQLite3: работа с БД
	datetime: Дата и время в Python
	json. dumps
	Selenium + Python
	Сложности при работе с Python
	DJANGO
	Flask
	Скрипт для ZPL принтера
	socket :Python Sockets
	Виртуальное окружение
	subprocess: выполнение bash команд из Python
	multiprocessing: несколько процессов одновременно
	psutil: cистемные ресурсы
	sys.argv: аргументы командной строки
	PyCharm: IDE
	pydantic: валидация данных
	paramiko: SSH из Python
	enumerate
	logging: запись в лог
	Обучение программированию на Python
	f-string

Поиск по сайту

Подпишитесь на Telegram канал @aofeed чтобы следить за выходом новых статей и обновлением старых

Перейти на канал

@aofeed

Задать вопрос в Телеграм-группе

@aofeedchat

Образование

Актуально сейчас

Разное

Поиск по сайту

Подпишитесь на Telegram канал @aofeed чтобы следить за выходом новых статей и обновлением старых

Перейти на канал

@aofeed

Задать вопрос в Телеграм-группе

@aofeedchat

Контакты и сотрудничество:
Рекомендую наш хостинг beget. ru
Пишите на [email protected] если Вы:
1. Хотите написать статью для нашего сайта или перевести статью на свой родной язык.
2. Хотите разместить на сайте рекламу, подходящуюю по тематике.
3. Реклама на моём сайте имеет максимальный уровень цензуры. Если Вы увидели рекламный блок недопустимый для просмотра детьми школьного возраста, вызывающий шок или вводящий в заблуждение — пожалуйста свяжитесь с нами по электронной почте
4. Нашли на сайте ошибку, неточности, баг и т.д. … …….
5. Статьи можно расшарить в соцсетях, нажав на иконку сети:

Разметка кода Python, PEP 8

Рекомендуется придерживаться следующих правил разметки кода

Отступы:

Используйте 4 пробела для добавления отступа.

Последующие строки обернутых элементов в скобки должны быть выравнены либо по вертикали, либо с помощью висящего отступа.

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

Правильно:

# Выравнивается с разделителем открытия.
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)
# У висячих строк должны быть отступы.
foo = long_function_name(
    var_one, var_two,
    var_three, var_four)

Не правильно

#Аргументы в первой строке запрещены, если не используется вертикальное выравнивание.
foo = long_function_name(var_one, var_two,
    var_three, var_four)
# Требуется дополнительное отступы, так как аргументы сливаются с кодом. 
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)

Правило 4 пробелов не является обязательным для строк продолжения.

По желанию:

# Висячие отступы могут иметь отступы, отличные от 4 пробелов.
foo = long_function_name (
  var_one, var_two,
  var_three, var_four)

Когда условная часть if достаточно длинная (более 79 символов) и мы должны записать ее в несколько строк, стоит отметить, что сочетание двухсимвольного ключевого слова (например, if ), одного пробела и открывающей скобки, при переносе, создает естественный отступ в 4 символа для последующих строк. Это может привести к визуальному конфликту с дальнейшим набором кода, вложенным в конструкцию if, которое также будет иметь отступ в 4 пробела. Этот PEP не занимает явной позиции о том, как следует дополнительно визуально отличать такие строки от вложенного кода внутри конструкции

if. Приемлемые варианты в этой ситуации можно посмотреть в примерах ниже, но не ограничиваться этим:

# Никаких дополнительных отступов, код в конструкции if 
# сливается с условием, что затрудняет чтение кода
if (this_is_one_thing and
    that_is_another_thing):
    do_something()

# Добавить комментарий, который обеспечит некоторое различие 
# в редакторе при помощи подсветки синтаксиса. 
if (this_is_one_thing and
    that_is_another_thing):
    # Так как ....
    do_something()

# Добавьте дополнительный отступ в строке условного продолжения.
if (this_is_one_thing
        and that_is_another_thing):
    do_something()

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

my_list = [
    1, 2, 3,
    4, 5, 6,
    ]
result = some_function_that_takes_arguments (
    'a', 'b', 'c',
    'd', 'e', 'f',
    )

или может быть на уровне первого символа строки, которая начинает многострочную конструкцию:

my_list = [
    1, 2, 3,
    4, 5, 6,
]
result = some_function_that_takes_arguments (
    'a', 'b', 'c',
    'd', 'e', 'f',
)

TAB или пробелы?

Пробелы являются предпочтительным методом отступа.

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

Python 3 запрещает смешивать использование табуляции и пробелов для отступа. Код с отступом в виде комбинации символов табуляции и пробелов должен быть преобразован исключительно в пробелы.

При вызове интерпретатора командной строки Python 2 с параметром -t выдает предупреждения о коде, который смешивает табуляции и пробелы. При использовании -tt эти предупреждения становятся ошибками. Эти варианты настоятельно рекомендуются!

Максимальная длина строки с кодом:

Ограничьте все строки максимум 79 символами.

Для строк документации или комментариев длина строки должна быть ограничена 72 символами.

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

Перенос по умолчанию в большинстве редакторов нарушает визуальную структуру кода, что делает его более трудным для понимания. Данные ограничения приняты для того, чтобы избежать автоматического переноса строк в редакторах с шириной окна, установленной на 80 символов, даже если он помещает маркер курсора в последний столбец. Некоторые IDE могут вообще не иметь авто-переноса строк.

Некоторые команды разработчиков предпочитают более длинные строки при написании кода. Исключительно для поддержания такого кода внутри команды, разрешается увеличить ограничение длины строки до 99 символов, при условии, что комментарии и документация должна быть ограничена 72 символами

Стандартная библиотека Python консервативна и требует ограничения строки до 79 символов (и строки документации/комментариев до 72).

Предпочтительный способ переноса длинных строк — это использование показанного выше переноса кода внутри скобок. Длинные строки можно разбить на несколько строк, заключив выражения в скобки.

income = (gross_wages
          + taxable_interest
          + (dividends - qualified_dividends)
          - ira_deduction
          - student_loan_interest)

Если такое не возможно, например, длинные строковые параметры в аргументах функций, то допустимо использование обратного слеша \.

with open('/path/to/some/file/you/want/to/read') as file_1, \
     open('/path/to/some/file/being/written', 'w') as file_2:
    file_2.write(file_1.read())

Еще один такой случай возможен с assert утверждениями.

Удостоверьтесь, что сделали отступ в 4 пробела для продолжения строки кода.

Перенос строки до или после двоичного оператора?

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

# Неправильно: 
# операторы сидят далеко от своих операндов
income = (gross_wages +
          taxable_interest +
          (dividends - qualified_dividends) -
          ira_deduction -
          student_loan_interest)

Чтобы решить проблему читаемости, математики следуют противоположному соглашению. Следуя традиции математики, обычно получается более читаемый код:

# Правильно: 
# легко сопоставлять операторы с операндами
income = (gross_wages
          + taxable_interest
          + (dividends - qualified_dividends)
          - ira_deduction
          - student_loan_interest)

В коде Python допускается перенос до или после двоичного оператора, если есть такое соглашение. Для нового кода предлагается математический стиль.

Пустые строки:

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

Определения методов внутри класса заключены в одну пустую строку.

Дополнительные пустые строки могут использоваться для разделения групп связанных функций. Пустые строки могут быть пропущены между связкой связанных строк (например, набором фиктивных реализаций).

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

Python принимает символ перевода формы control-L (т.е. ^ L) в качестве пробела. Многие инструменты обрабатывают эти символы как разделители страниц, поэтому, вы можете использовать их для разделения страниц связанных разделов вашего файла. Обратите внимание, что некоторые редакторы и IDE могут не распознавать control-L.

Кодировка файла с кодом:

Код в основном дистрибутиве Python всегда должен использовать UTF-8 (или ASCII в Python 2).

Файлы, использующие ASCII (в Python 2) или UTF-8 (в Python 3), не должны иметь декларации кодировки.

В стандартной библиотеке, кодировки, отличные от заданных по умолчанию, следует использовать только для целей тестирования или в тех случаях, когда в комментариях или строке документации необходимо упомянуть имя автора, содержащее символы, отличные от ASCII. В противном случае использование \x , \u , \U или \N escape-файлов является предпочтительным способом включения данных не-ASCII в строковые литералы.

Для Python 3.0 и выше, для стандартной библиотеки предписана следующая политика. Все идентификаторы в стандартной библиотеке Python ДОЛЖНЫ использовать идентификаторы только ASCII и ДОЛЖНЫ использовать английские слова везде, где это возможно (сокращения и технические термины, которые не являются английскими). Кроме того, все строковые литералы и комментарии также должны быть в ASCII.

Единственными исключениями являются:

Контрольные примеры, тестирующие функции, отличные от ASCII,
Имена авторов. Авторы, чьи имена не основаны на латинском алфавите, ДОЛЖНЫ обеспечить транслитерацию своих имен.

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

Импорт:

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

# Правильно:
import os
import sys
# Неправильно:
import sys, os

Это нормально, хотя:

from subprocess import Popen, PIPE

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

Импорт должен быть сгруппирован в следующем порядке:

Импорт стандартной библиотеки.
Связанный импорт третьей стороны.
Локальный импорт приложений или библиотек.

Вы должны поставить пустую строку между каждой группой импорта.

Рекомендуется абсолютный импорт, так как он обычно более читабелен и, как правило, ведет себя лучше (или, по крайней мере, дает лучшие сообщения об ошибках), если система импорта настроена неправильно (например, когда каталог внутри пакета заканчивается в sys.path ):

import mypkg.sibling
from mypkg import sibling
from mypkg.sibling import example

Однако явный относительный импорт является приемлемой альтернативой абсолютному импорту, особенно когда речь идет о сложном макете в пакете, где использование абсолютного импорта было бы излишне многословным:

from . import sibling
from .sibling import example

Код стандартной библиотеки должен избегать сложных макетов пакетов и всегда использовать абсолютный импорт.

Неявный относительный импорт никогда не должен использоваться и был удален в Python 3.

При импорте класса из модуля, обычно можно записать следующее:

from myclass import MyClass
from foo.bar.yourclass import YourClass

Если это написание вызывает локальные конфликты имен, то запишите импорт через точку:

import myclass
import foo.bar.yourclass

и используйте myclass.MyClass и foo.bar.yourclass.YourClass.

Следует избегать импорта подстановочных знаков ( from <module> import * ), так как из-за этого неясно, какие имена присутствуют в пространстве имен, запутывает как читателей, так и многие автоматизированные инструменты. Существует один оправданный вариант использования для импорта с использованием подстановочного знака, который заключается в повторной публикации внутреннего интерфейса как части общедоступного API.

При повторной публикации имен, все же применяются приведенные ниже рекомендации, касающиеся открытых и внутренних интерфейсов.

Расположение имен «dunders» в коде:

Имена «dunders» (имена с двумя начальными и двумя замыкающими подчеркиваниями), такие как __all__ , __author__ , __version__ и т. ., Должны быть помещены после строки документации модуля, но перед любыми операторами импорта, кроме __future__. Python предписывает, что в __future__ импорт должен стоять перед любым другим кодом, кроме строк документации:

"""This is the example module.
This module does stuff.
"""
from __future__ import barry_as_FLUFL
__all__ = ['a', 'b', 'c']
__version__ = '0.1'
__author__ = 'Cardinal Biggles'
import os
import sys

Кавычки в строках:

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

Для строк с тройными кавычками всегда используйте символы двойной кавычки, чтобы соответствовать соглашению с документированной строкой в PEP 257.

Синтаксис

. Как сделать разрыв строки (продолжение строки) в Python?

Дано:

 e = 'a' + 'b' + 'c' + 'd'

Как написать это в две строки?

 е = 'а' + 'б' +
    'с' + 'г'

python
синтаксис
разрывы строк
длинные строки

Что за линия? Вы можете без проблем иметь аргументы на следующей строке:

 а = вещи (блабла2, блабла3, блабла4, блабла5, блабла5,
            блабла6, блабла7)

В противном случае вы можете сделать что-то вроде этого:

 if (a == True and
    б == Ложь):

или с явным разрывом строки:

, если a == True и \
   б == Ложь:

Дополнительные сведения см. в руководстве по стилю.

Используя круглые скобки, ваш пример можно записать в несколько строк:

 a = ('1' + '2' + '3' +
    «4» + «5»)

Тот же эффект можно получить, используя явный разрыв строки:

 а = '1' + '2' + '3' + \
    «4» + «5»

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

Из PEP 8 — Руководство по стилю для кода Python :

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

Обратная косая черта иногда может быть уместна. Например, длинные, множественные операторы with не могут использовать неявное продолжение, поэтому допустима обратная косая черта:
.

 с открытым ('/path/to/some/file/you/want/to/read') как file_1, \
     открыть('/путь/к/какому/файлу/существующему/написанному', 'w') как файл_2:
     файл_2.запись (файл_1.чтение())

Еще один такой случай — операторы assert.

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

 класс Прямоугольник (Blob):
  def __init__(я, ширина, высота,
                цвет='черный', акцент=нет, подсветка=0):
       если (ширина == 0 и высота == 0 и
          цвет == «красный» и акцент == «сильный» или
           выделить> 100):
           поднять ValueError("извините, вы проиграли")
       если ширина == 0 и высота == 0 и (цвет == 'красный' или
                                          ударение отсутствует):
           поднять ValueError("Я так не думаю -- значения %s, %s" %
                            (ширина высота))
       Blob. __init__(я, ширина, высота,
                     цвет, выделение, выделение)file_2.write(file_1.read())

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

Стиль Дональда Кнута при разбиении до бинарный оператор выравнивает операторы по вертикали, тем самым уменьшая нагрузку на глаз при определении того, какие элементы добавляются и вычитаются.

Из PEP8: Следует ли разрывать строку до или после бинарного оператора? :

Дональд Кнут объясняет традиционное правило в своей серии «Компьютеры и верстка»: «Хотя формулы внутри абзаца всегда ломаются после бинарных операций и отношений, отображаемые формулы всегда ломаются перед бинарными операциями»[3].

Следуя традиции из математики, обычно получается более читаемый код:

 # Да: легко сопоставить операторы с операндами

 доход = (валовая_заработная плата
          + налогооблагаемый_процент
          + (дивиденды - квалифицированные_дивиденды)
          - ira_deduction
          - student_loan_interest)

В коде Python допустимо прерывание до или после бинарного оператора, если соглашение локально согласовано. Для нового кода предлагается стиль Кнута.

[3]: The TeXBook Дональда Кнута, страницы 195 и 196

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

Дополнительные сведения см. в разделе Идиомы и антиидиомы Python (для Python 2 или Python 3).

Поставьте \ в конце строки или заключите оператор в круглые скобки ( .. ) . От IBM:

 b = ((i1 < 20) и
     (i2 < 30) и
     (i3 < 40))

или

 b = (i1 < 20) и \
    (i2 < 30) и \
    (i3 < 40)

Вы можете разбивать строки между скобками и фигурными скобками. Кроме того, вы можете добавить символ обратной косой черты \ к строке, чтобы явно разорвать ее:

 х = (кортежи_первое_значение,
     второе_значение)
у = 1 + \
    2

Из первых уст: Явная линия присоединяюсь к
Две или более физических линий могут быть объединены в логические строки с помощью символы обратной косой черты ( \ ), как показано ниже: когда физическая линия заканчивается на обратная косая черта, которая не является частью строки литерал или комментарий, он соединяется с следующее, образующее единую логическую строку, удалив обратную косую черту и после символа конца строки. Для пример:
, если 1900 < год < 2100 и 1 <= месяц <= 12 \
   и 1 <= день <= 31 и 0 <= час < 24 \
   и 0 <= минуты < 60 и 0 <= секунды < 60: # Похоже на правильную дату
        вернуть 1
 
Строка, заканчивающаяся обратной косой чертой, не может нести комментарий. Обратная косая черта не продолжить комментарий. Обратная косая черта делает не продолжать токен, кроме строки литералы (т. е. токены, отличные от строковые литералы не могут быть разделены между физические строки с использованием обратной косой черты). А обратная косая черта запрещена в других местах строка вне строкового литерала.

Если вы хотите прервать свою строку из-за длинной литеральной строки, вы можете разбить эту строку на части:

 long_string = "очень длинная строка"
print("очень длинная строка")

будет заменено на

 long_string = (
  "а"
  "очень "
  "длинный "
  "нить"
)
Распечатать(
  "а"
  "очень "
  "длинный "
  "нить"
)

Вывод для обоих операторов печати:

очень длинная строка

Обратите внимание на круглые скобки в притворстве.

Обратите также внимание, что разбиение литеральных строк на части позволяет использовать литеральный префикс только в частях строки и смешивать разделители:

 s = (
  '''2+2='''
  ж"{2+2}"
)

Можно также разбить вызов методов ( obj. method() ) на несколько строк.

Заключите команду в круглые скобки " () " и растяните несколько строк:

 > res = (some_object
         .применить (аргументы)
         .фильтр()
         .ценности)

Например, я нахожу это полезным при цепочке вызовов методов объектов Pandas/Holoviews.

Возможно, это не Pythonic-способ, но я обычно использую список с функцией соединения для записи длинной строки, например SQL-запросов:

 query = " ".join([
    'ВЫБЕРИТЕ * ИЗ "ИмяТаблицы"',
    'ГДЕ "SomeColumn1"=ЗНАЧ',
    'ЗАКАЗАТЬ ПО "SomeColumn2"',
    'ОГРАНИЧЕНИЕ 5;'
])

Взято из «Автостопом по Python» (продолжение строки):

Если логическая строка кода длиннее допустимого предела, ее необходимо разделить на несколько физических строк. Интерпретатор Python будет соединять последовательные строки, если последним символом строки является обратная косая черта. Это полезно в некоторых случаях, но обычно его следует избегать из-за его ненадежности: пробел, добавленный в конец строки после обратной косой черты, нарушит код и может привести к неожиданным результатам.
Лучшим решением является использование круглых скобок вокруг ваших элементов. Если оставить незакрытую скобку в конце строки, интерпретатор Python будет присоединяться к следующей строке до тех пор, пока скобки не будут закрыты. То же самое относится и к фигурным и квадратным скобкам.
Однако , чаще всего необходимость разбивать длинную логическую строку является признаком того, что вы пытаетесь сделать слишком много вещей одновременно, что может ухудшить читабельность.

С учетом сказанного, вот пример, учитывающий множественный импорт (при превышении ограничений строки, определенных в PEP-8), также применяемый к строкам в целом:

 из импорта приложения (
    приложение, прерывание, make_response, перенаправление, render_template, запрос, сеанс
)

разрывов строк — Как напечатать разрыв строки в функции python?

спросил 11 лет, 11 месяцев назад

Изменено 2 года назад

Просмотрено 790 тысяч раз

В моем коде есть список строк;

 А = ['а1', 'а2', 'а3' . ..]
B = ['b1', 'b2', 'b3' ...]

, и я хочу вывести их через разрыв строки, например:

 >a1
б1
>а2
Би 2
>а3
б3

Я пробовал:

 напечатать '>' + A + '/n' + B

Но /n не распознается как разрыв строки.

питон
разрывы строк

У вас косая черта в обратном порядке, она должна быть "\n"

Символ новой строки на самом деле '\n' .

Все три способа, которые вы можете использовать для символа новой строки:

 '\n'
"\п"
"""\n"""

 >>> А = ['а1', 'а2', 'а3']
>>> В = ['b1', 'b2', 'b3']
>>> для х в А:
        для я в B:
            напечатать ">" + х + "\n" + я

Выходы:

 >a1
б1
>а1
Би 2
>а1
б3
>а2
б1
>а2
Би 2
>а2
б3
>а3
б1
>а3
Би 2
>а3
б3

Обратите внимание, что вы используете /n , что является , а не правильным!

 для пары в молнии (A, B):
 print ">"+'\n'.

Штирлиц — Сеть печатных салонов в Перми