Основы синтаксиса Python. Синтаксис языка Python

Синтаксис языка Python во многом похож на синтаксис таких языков, как Perl, C и Java, но вместе с этим имеет ряд отличий от этих языков программирования. В этой статье мы рассмотрим необходимые основы этого языка программирования .

Первая программа на Python:

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

Интерактивный режим программирования:

Без передачи в качестве аргумента названия файла запустит интерпретатор Python :

Введите следующий текст после строки приглашения Python и нажмите Enter:

>>> print "Hello, Python!"

Если вы все сделали правильно, то интерпретатор выдаст строку:

Если вы получили ошибку - удостоверьтесь, что правильно переписали код и что используете интерпретатор версии 2.х (для версии 3.х следует использовать команду print ("Hello, Python"))

Скриптовый режим программирования:

Запуск в командной строке python с названием файла (он еще называется скрипт) в качестве параметра, начнет выполнение кода, записанного в данном файле. После завершения выполнения скрипта, интерпретатор будет снова неактивен.

Давайте, создадим простую программу-скрипт на Python . Откройте любой текстовый редактор (Sublime, Notepad++, gedit...), создайте в нем файл с именем test и расширением.py (все файлы, содержащие код на Python должны иметь расширение .py ) и запишите в этот файл уже знакомый нам код и сохраните файл:

Print "Hello, Python!"

(Предполагается, что интерпретатор Python у вас задан в переменной PATH, то есть вы находясь в любой директории можете ввести python для запуска интерпретатора)

После этого введите следующую строку в командной строке и нажмите Enter:

Идентификаторы в Python:

Идентификаторы в Python это имена используемые для обозначения переменной, функции, класса, модуля или другого объекта. Идентификатор должен начинаться с буквы (от a до Z) или со знака подчеркивания (_), после которых может идти произвольное количество букв, знаков подчеркивания и чисел (от 0 до 9).

В Python недопустимо использование знаков препинания или специальных символов, таких как @, $ или % в качестве идентификаторов. Кроме того, Python чуствителен к регистру, то есть cat и Cat это два разных имени.

В Python существует следующая договоренность для названия идентификаторов:

• Имена классов начинаются с большой буквы, все остальные идентификаторы - с маленькой.
• Использования знака подчеркивания в качестве первого символа идентификатора означает, что данный идентификатор является частным (закрытым от использования вне класса).
• Если идентификатор начинается и заканчивается двумя знаками подчеркивания (например, __init__) это означает, что он является специальным именем, определенным внутри языка.

Зарезервированые (ключевые) слова в Python:

В данной таблице собраны все ключевые слова Python .

and	elif	if	print
as	else	import	raise
assert	except	in	return
break	exec	is	try
class	finally	lambda	while
continue	for	not	which
def	from	or	yield
del	global	pass

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

Help("keywords")

Строки и отступы:

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

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

Например, этот блок кода будет работать (хотя так писать не стоит):

If True: print "Hi" else: print "Bye"

А этот уже вызовет ошибку:

If True: print "Hi" print "Bye"

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

Многострочные выражения:

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

Total = item1 + \ item2 + \ item3

Выражения, которые находятся внутри скобок: квадратных (), фигурных ({ }) или круглых (()) не нуждаются в символе переноса строки. Например:

Days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]

Кавычки в Python:

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

Name = "wasd" description = "Some text" biography = """ Some long text for few lines of code """

| |

Комментарии – это строки, которые существуют в коде программы, но игнорируются компиляторами и интерпретаторами. Комментарии делают код более удобочитаемым, так как позволяют предоставить пользователям дополнительную информацию или добавить объяснение того или иного блока кода.

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

Синтаксис комментариев

Комментарии в Python начинаются с хеша (символа #), после которого ставится пробел.

Общий вид комментария:

# This is a comment

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

В простейшей программе «Hello, World!» комментарий может выглядеть так:

# Print “Hello, World!” to console
print("Hello, World!")

В цикле for, который итерирует списки, могут быть такие комментарии:

# Define sharks variable as a list of strings
sharks = ["hammerhead", "great white", "dogfish", "frilled", "bullhead", "requiem"]
# For loop that iterates over sharks list and prints each string item
for shark in sharks:
print(shark)

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

Для примера рассмотрим функцию again() из руководства :

...
# Define again() function to ask user if they want to use the calculator again
def again():
# Take input from user
calc_again = input("""
Do you want to calculate again?
Please type Y for YES or N for NO.
""")
# If user types Y, run the calculate() function
if calc_again == "Y":
calculate()
# If user types N, say good-bye to the user and end the program
elif calc_again == "N":
print("See you later.")
# If user types another key, run the function again
else:
again()

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

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

Блочные комментарии

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

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

Следующий блочный комментарий описывает действия функции main().

# The main function will parse arguments via the parser variable. These
# arguments will be defined by the user on the console. This will pass
# the word argument the user wants to parse along with the filename the
# user wants to use, and also provide help text if the user does not
# correctly pass the arguments.
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"word",
help="the word to be searched for in the text file."
parser.add_argument(
"filename",
help="the path to the text file to be searched through"
...

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

Строчные комментарии

Строчные комментарии следуют за кодом (то есть, находятся в одной строке с теми выражениями, которые они объясняют).

Строчный комментарий выглядит так:

# Inline comment about the code

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

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

z = 2.5 + 3j # Create a complex number

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

x = 8 # Initialize x with an arbitrary number

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

Программа представляет собой набор алгоритмов, которые обеспечивают выполнение необходимых действий. Условно таким же образом можно запрограммировать обычного человека, написав точные команды, для того чтобы, например, он приготовил чай. Если в последнем варианте будет использоваться естественная речь (русская, украинская, английская, корейская и т. д.), то для компьютера понадобится специальный язык программирования. Python - один из таковых. Среда программирования впоследствии переведет команды в и цель человека, ради которой создавался алгоритм, будет выполнена. «Питон» имеет свой синтаксис, который будет рассмотрен ниже.

История языка

Разработка началась в 1980-х году, а завершилась она в 1991. Язык Python был создан Гвидо ван Россумом. Хоть основным символом «Питона» является змея, назван он был так в честь комедийного американского шоу.

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

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

Особенности «Питона»

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

Многие синтаксические системы были созданы с опорой на объектно-ориентированное программирование. Не исключением является и язык Python. Для чего же именно он появился на свет? Он облегчит обучение новичкам, поможет вспомнить некоторые элементы уже квалифицированным сотрудникам.

Синтаксис языка

Как уже было сказано, код читается достаточно легко и просто. «Питон» имеет последовательные команды, отличающиеся четкостью выполнения. В принципе, используемые операторы не покажутся даже новичкам трудными. Этим и отличается язык Python. Синтаксис его легок и прост.

Традиционные операторы:

• При задавании условия следует использовать конструкцию if-else. Если таких строк слишком много, можно вписывать команду elif.
• Class предназначен для понимания класса.
• Один из простых операторов - pass. Он ничего не делает, вписывается для пустых блоков.
• Цикловыми командами являются while и for.
• Функция, метод и генератор определяется благодаря def.

Кроме одиночных слов, в качестве операторов язык программирования Python позволяет использовать и выражения. Благодаря использованию цепочек строк можно уменьшить количество отдельных команд и скобок. Используются и так называемые ленивые вычисления, т. е. те, которые выполняются лишь тогда, когда того требует условие. К ним относятся and и or.

Процесс написания программ

Интерпретатор работает на едином механизме: при написании строки (после которой ставится «Энтер») она сразу же выполняется, и человек может уже видеть какой-то результат. Это пригодится и будет достаточно удобным для новичков или тех, кто хочет протестировать небольшой кусочек кода. В компилируемых средах пришлось бы сначала написать программу целиком, лишь потом запустить ее и проверить на ошибки.

Язык программирования Python (для начинающих, как уже стало понятно, он подходит идеально) в операционной системе Linux позволяет работать непосредственно в самой консоли. Следует написать в командной строке название кода «Питон» на английском языке. Свою первую программу создать будет нетрудно. Прежде всего, стоит учитывать и то, что пользоваться интерпретатором здесь можно в качестве калькулятора. Так как с синтаксисом зачастую молодые и начинающие специалисты не дружат, то написать алгоритм можно таким образом:

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

Данные, используемые «Питоном»

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

Наиболее распространенные типы данных, которым пользуется язык программирования Python:

• Integer. Речь идет о целых числах, имеющих как отрицательное, так и положительное значение. Ноль также входит в данный тип.
• Для того чтобы интерпретатор понял, что работает с дробными частями, следует задать тип float point. Как правило, им пользуются в случае использования чисел с варьирующейся точкой. Следует помнить, что при написании программы нужно придерживаться записи «3.25», а не использовать запятую «3,25».
• В случае добавления строк язык программирования Python позволяет добавить тип string. Зачастую слова или фразы заключаются в одинарные или

Недостатки и преимущества

В последние несколько десятилетий людей больше интересовало, как больше времени потратить на освоение данных и меньше - на то, чтобы они были обработаны компьютером. Язык о котором лишь положительные, является высшим кодом.

Недостатков у «Питона» практически нет. Единственный серьезный минус - медлительность при выполнении алгоритма. Да, если сравнивать его с «Си» или «Джава», он, откровенно говоря, черепашка. Объясняется это тем, что данный

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

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

Сейчас над улучшением «Питона» работает не одна группа программистов, поэтому не факт, что код, написанный на С++ будет лучше, чем тот, который создан при помощи Python.

С какой версией лучше работать?

Сейчас широко используются сразу две версии такой синтаксической системы, как язык Python. Для начинающих выбор между ними будет достаточно трудным. Следует заметить тот факт, что 3.х все еще находится на разработке (хотя и выпущен в массы), в то время как 2.х - полностью завершенная версия. Многие советуют использовать 2.7.8, так как она практически не лагает и не сбивается. В 3.х версии нет радикальных изменений, поэтому в любое время свой код можно перенести в среду программирования с обновлением. Чтобы скачать необходимую программу, следует зайти на официальный сайт, выбрать свою операционную систему и дождаться окончания загрузки.

Комментарии

Комментарии, противоречащие коду, хуже, чем отсутствие комментариев.

Всегда исправляйте комментарии, если меняете код!

Комментарии должны являться законченными предложениями. Если комментарий - фраза или предложение, первое слово должно быть написано с большой буквы, если только это не имя переменной, которая начинается с маленькой буквы (никогда не изменяйте регистр переменной!).

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

Ставьте два пробела после точки в конце предложения.

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

Блоки комментариев

Блок комментариев обычно объясняет код (весь, или только некоторую часть), идущий после блока, и должен иметь тот же отступ, что и сам код. Каждая строчка такого блока должна начинаться с символа # и одного пробела после него (если только сам текст комментария не имеет отступа).

Абзацы внутри блока комментариев разделяются строкой, состоящей из одного символа #.

«Встрочные» комментарии

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

Такой комментарий находится в той же строке, что и инструкция. «Встрочные» комментарии должны отделяться по крайней мере двумя пробелами от инструкции. Они должны начинаться с символа # и одного пробела.

Комментарии в строке с кодом не нужны и только отвлекают от чтения, если они объясняют очевидное. Не пишите вот так:

x = x + 1 # Increment x

Впрочем, такие комментарии иногда полезны:

x = x + 1 # Компенсация границы

Python Комментарии исключительно рациональны и имеют ряд особенностей:

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

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

СОВЕТ Помните — комментарии нужны программисту, а не интерпретатору Python. Вставка комментариев в код позволит через некоторое время быстро вспомнить предназначение фрагмента кода.

В языке Python присутствует только однострочный комментарий. Он начинается с символа #:

# Это комментарий

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

Например, в следующем примере комментарий расположен после инструкции, предписывающей вывести надпись «Привет, мир!»:

рrint(«Привет, мир!») # Выводим надпись с помощью функции print()

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

# рrint(«Привет, мир!») Эта инструкция выполнена не будет

Если символ # расположен внутри кавычек или апострофов, то он не является символом комментария:

print(«# Это НЕ комментарий»)

Так как в языке Python нет многострочного комментария, то часто комментируемый фрагмент размещают внутри утроенных кавычек (или утроенных апострофов):

«»»
Эта инструкция выполнена не будет
рrint(«Привет, мир!»)
«»»

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

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

Строки документирования являются «топливом» для help ():

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

Функция help () при составлении документации получает информацию из этого атрибута. Такие строки называются строками документирования.

Приглашаю всех высказываться в

В приведенных далее примерах, ввод и вывод различаются присутствием и отсутствием приглашений соответственно (приглашениями являются >>> и...): чтобы воспроизвести пример - вам нужно ввести всё, что следует за приглашением, после его появления; строки, не начинающиеся с приглашений являются выводом интерпретатора. Обратите внимание, что строка, в которой содержится лишь вспомогательное приглашение (" ... ") означает, что вам нужно ввести пустую строку - этот способ используется для завершения многострочных команд.

Большинство примеров в этом руководстве - даже те, которые вводятся в интерактивном режиме - содержат комментарии. Комментарии в Python начинаются с символа решетки # (hash) - и продолжаются до физического конца строки. Комментарии могут находиться как в начале строки, так и следовать за пробельными символами или кодом - но не содержаться внутри строки. Символ решётки в строке остаётся лишь символом решётки. Поскольку комментарии предназначены для того, чтобы сделать код более понятным, и не интерпретируются Python - при вводе примеров они могут быть опущены.

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

# это первый комментарий SPAM = 1 # а это второй комментарий # ... и наконец третий! STRING = "# Это не комментарий."

Использование Python в качестве калькулятора

Давайте опробуем несколько простых команд Python. Запустите интерпретатор и дождитесь появления основного приглашения - >>> . (Это не должно занять много времени.)

Числа

Поведение интерпретатора сходно поведению калькулятора: вы вводите выражение, а в ответ он выводит значение. Синтаксис выражений привычен: операции + , - , * и / работают также как и в большинстве других языков (например, Паскале или C); для группировки можно использовать скобки. Например:

>>> 2 +2 4 >>> # Это комментарий ... 2 +2 4 >>> 2 +2 # а вот комментарий на одной строке с кодом 4 >>> (50 -5 * 6 ) /4 5.0 >>> 8 /5 # При делении целых чисел дробные части не теряются 1.6000000000000001

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

>>> print (8 /5 ) 1.6

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

Для получения целого результата при делении целых чисел, отсекая дробные результаты, предназначена другая операция: // :

>>> # Деление целых чисел возвращает округлённое к минимальному значение: ... 7 //3 2 >>> 7 //-3 -3

Знак равенства ("=") используется для присваивания переменной какого-либо значения. После этого действия в интерактивном режиме ничего не выводится:

>>> width = 20 >>> height = 5 * 9 >>> width * height 900

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

>>> x = y = z = 0 # Нулевые x, y и z >>> x 0 >>> y 0 >>> z 0

Переменные должны быть определены (defined) (должны иметь присвоенное значение) перед использованием, иначе будет сгенерирована ошибка:

>>> # попытка получить доступ к неопределённой переменной ... n Traceback (most recent call last) : File "" , line 1, in < module> NameError : name "n" is not defined

Присутствует полная поддержка операций с плавающей точкой; операции над операндами смешанного типа конвертируют целочисленный операнд в число с плавающей запятой:

>>> 3 * 3.75 / 1.5 7.5 >>> 7.0 / 2 3.5

Поддерживаются и комплексные числа, добавлением к мнимым частям суффикса j или J . Комплексные числа с ненулевым вещественным компонентом записываются в виде (<вещественная_часть> +<мнимая_часть> j) , или могут быть созданы с помощью функции complex(<вещественная_часть> , <мнимая_часть> ) .

>>> 1j * 1J (-1+0j) >>> 1j * complex (0 , 1 ) (-1 +0j) >>> 3 +1j* 3 (3 +3j) >>> (3 +1j) * 3 (9 +3j) >>> (1 +2j) /(1 +1j) (1.5 +0.5j)

Комплексные числа всегда представлены в виде двух чисел с плавающей запятой - вещественной и мнимой частями. Для получения этих частей из комплексного числа z используется z.real и z.imag соответственно.

>>> a=1.5 +0.5j >>> a.real 1.5 >>> a.imag 0.5

Функции конвертации (приведения) к вещественным и целым числам (float() , int()) не работают с комплексными числами, так как нет единственно правильного способа сконвертировать комплексное число в вещественное. Используйте функцию abs(z) чтобы получить модуль числа (в виде числа с плавающей точкой) или z.real чтобы получить его вещественную часть:

>>> a=3.0+4.0j >>> float (a) Traceback (most recent call last) : File "" , line 1, in ? TypeError : can` t convert complex to float ; use abs (z) >>> a.real 3.0 >>> a.imag 4.0 >>> abs (a) # sqrt(a.real**2 + a.imag**2) 5.0 >>>

В интерактивном режиме последнее выведенное выражение сохраняется в переменной _ . Это значит, что если вы используете Python в качестве настольного калькулятора - всегда есть способ продолжить вычисления с меньшими усилиями, например:

>>> tax = 12.5 / 100 >>> price = 100.50 >>> price * tax 12.5625 >>> price + _ 113.0625 >>> round (_, 2 ) 113.06 >>>

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

Строки

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

>>> "spam eggs" "spam eggs" >>> "doesn\" t" "doesn"t" >>> "doesn"t" "doesn"t" >>> ""Yes," he said." ""Yes," he said." >>> "\" Yes,\" he said." ""Yes," he said." >>> ""Isn\" t," she said." ""Isn\" t," she said."

Интерпретатор выводит результаты операций над строками тем же способом, каким они были введены: обрамляя в кавычки, и, кроме того, экранируя обратными слэшами внутренние кавычки и другие забавные символы - для того, чтобы отобразить точное значение. Строка заключается в двойные кавычки, если строка содержит одинарные кавычки и ни одной двойной, иначе она заключается в одинарные кавычки. Повторимся, функция print() предоставляет более читаемый вывод.

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

Hello = "This is a rather long string containing\n \ several lines of text just as you would do in C.\n \ Note that whitespace at the beginning of the line is\ significant." print (hello)

Обратите внимание, что новые строки все ещё нужно подключать в строку через \n ; новая строка, за которой следут обратный слэш - не обрабатывается. Запуск примера выведет следующее:

This is a rather long string containing several lines of text just as you would do in C. Note that whitespace at the beginning of the line is significant.

Если мы объявим строковой литерал сырым (raw) - символы \n не будут конвертированы в новые строки, но и обратный слэш в конце строки, и символ новой строки в исходном коде - будут добавлены в строку в виде данных. Следовательно, код из примера:

Hello = r"This is a rather long string containing\n \ several lines of text much as you would do in C." print (hello)

This is a rather long string containing\n\ several lines of text much as you would do in C.

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

Print (""" Usage: thingy -h Display this usage message -H hostname Hostname to connect to """ )

выводит в результате следующее:

Usage: thingy -h Display this usage message -H hostname Hostname to connect to

Строки могут конкатенироваться (склеиваться вместе) операцией + и быть повторенными операцией * :

>>> word = "Help" + "A" >>> word "HelpA" >>> "<" + word* 5 + ">" ""

Два строковых литерала, расположенные друг за другом, автоматически конкатенируются; первая строка в предыдущем примере также могла быть записана как word = "Help" "A" ; это работает только с двумя литералами - не с произвольными выражениями, содержащими строки.

>>> "str" "ing" # <- Так - верно "string" >>> "str" .strip () + "ing" # <- Так - верно "string" >>> "str" .strip () "ing" # <- Так - не верно File "" , line 1, in ? "str" .strip () "ing" ^ SyntaxError : invalid syntax

Строки могут быть проиндексированы; также как и в C, первый символ строки имеет индекс 0 . Отсутствует отдельный тип для символов; символ является строкой с единичной длиной. Как и в языке программирования Icon, подстроки могут определены через нотацию срезов (slice): два индекса, разделенных двоеточием.

>>> word[ 4 ] "A" >>> word[ 0 :2 ] "He" >>> word[ 2 :4 ] "lp"

Индексы срезов имеют полезные значения по умолчанию; опущенный первый индекс заменяется нулём, опущенный второй индекс подменяется размером срезаемой строки.

>>> word[ :2 ] # Первые два символа "He" >>> word[ 2 :] # Всё, исключая первые два символа "lpA"

В отличие от строк в C, строки Python не могут быть изменены. Присваивание по позиции индекса строки вызывает ошибку:

>>> word[ 0 ] = "x" Traceback (most recent call last) : File "" , line 1, in ? TypeError : "str" object doesn"t support item assignment >>> word[:1] = " Splat" Traceback (most recent call last): File "", line 1, in ? TypeError: " str " object doesn" t support slice assignment

Тем не менее, создание новой строки со смешанным содержимым - процесс легкий и очевидный:

>>> "x" + word[ 1 :] "xelpA" >>> "Splat" + word[ 4 ] "SplatA"

Полезный инвариант операции среза: s[:i] + s эквивалентно s .

>>> word[ :2 ] + word[ 2 :] "HelpA" >>> word[ :3 ] + word[ 3 :] "HelpA"

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

>>> word[ 1 :100 ] "elpA" >>> word[ 10 :] "" >>> word[ 2 :1 ] ""

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

>>> word[ -1 ] # Последний символ "A" >>> word[ -2 ] # Предпоследний символ "p" >>> word[ -2 :] # Последние два символа "pA" >>> word[ :-2 ] # Всё, кроме последних двух символов "Hel"

Но обратите внимание, что -0 действительно эквивалентен 0 - это не отсчет справа.

>>> word[ -0 ] # (поскольку -0 равен 0) "H"

Отрицательные индексы вне диапазона обрезаются, но не советуем делать это с одно-элементными индексами (не-срезами ):

>>> word[ -100 :] "HelpA" >>> word[ -10 ] # ошибка Traceback (most recent call last) : File "" , line 1, in ? IndexError : string index out of range

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

+---+---+---+---+---+ | H | e | l | p | A | +---+---+---+---+---+ 0 1 2 3 4 5 -5 -4 -3 -2 -1

Первый ряд чисел дает позицию индексов строки от 0 до 5; второй ряд описывает соответствующие отрицательные индексы. Срез от i до j состоит из всех символов между правым и левым краями, отмеченными, соответственно, через i и j .

Для всех индексов, больших или равных нулю, длина среза - разность между индексами, при условии что оба индекса находятся в диапазоне. Например, длина word - 2.

Встроенная функция len() возвращает длину строки:

>>> s = "supercalifragilisticexpialidocious" >>> len (s) 34

Смотрите также : Перечисляемые типы Строки - вид перечисляемых типов и они поддерживают привычные для этих типов операции. Строковые методы Строки поддерживают большое количество методов для поиска и простых трансформаций. Форматирование строк Здесь описано форматирование строк с применением функции str.format() Операции форматирования строк в старом стиле Операции форматирования, вызывающиеся тогда, когда обычные строки или строки в Unicode оказываются левым операндом относительно операции % , более детально рассмотрены здесь.

О Unicode

Начиная с Python версии 3.0, строковый тип поддерживает только Unicode (см. http://www.unicode.org/).

Преимущество набора Unicode состоит в том, что он предоставляет порядковый номер для любого символа из любой письменности, использовавшейся в современных или древнейших текстах. До этих пор для символов в сценарии было доступно лишь 256 номеров. Тексты обычно привязывались к кодовой странице, которая устанавливала в соответствие порядковые номера и символы сценария. Это приводило к серьезной путанице, особенно в том, что касалось интернационализации программного продукта. Unicode решает эти проблемы, определяя единую кодовую страницу для всех письменностей.

Для вставки в строку специального символа можно использовать Unicode-экранирование (Python Unicode-Escape encoding). Следующий пример всё пояснит:

>>> "Hello\u 0020World !" "Hello World !"

Экранированная последовательность \u0020 задаёт символ Unicode с порядковым номером 0x0020 (символ пробела).

Другие символы интерпретируются с использованием соответствующих им порядковых значений тем же способом, что и порядковые номера Unicode. Первые 128 символов кодировки Unicode полностью совпадают с 128 символами кодировки Latin-1 , использующейся во многих западных странах.

Помимо стандартных способов кодирования, Python предоставляет целый набор различных способов создания Unicode-строк, основываясь на известной кодировке.

Для конвертирования Unicode-строки в последовательность байтов с использованием желаемой кодировки, строковые объекты предоставляют метод encode() , принимающий единственный параметр - название кодировки. Предпочитаются названия кодировок, записанные в нижнем регистре.

>>> "Äpfel" .encode ("utf-8" ) b"\x c3\x 84pfel"

Списки

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

>>> a = [ "spam" , "eggs" , 100 , 1234 ] >>> a [ "spam" , "eggs" , 100 , 1234 ]

Подобно индексам в строках, индексы списков начинаются с нуля, списки могут быть срезаны, объединены (конкатенированы ) и так далее:

>>> a[ 0 ] "spam" >>> a[ 3 ] 1234 >>> a[ -2 ] 100 >>> a[ 1 :-1 ] [ "eggs" , 100 ] >>> a[ :2 ] + [ "bacon" , 2 * 2 ] [ "spam" , "eggs" , "bacon" , 4 ] >>> 3 * a[ :3 ] + [ "Boo!" ] [ "spam" , "eggs" , 100 , "spam" , "eggs" , 100 , "spam" , "eggs" , 100 , "Boo!" ]

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

>>> a [ "spam" , "eggs" , 100 , 1234 ] >>> a[ 2 ] = a[ 2 ] + 23 >>> a [ "spam" , "eggs" , 123 , 1234 ]

Присваивание срезу также возможно, и это действие может даже изменить размер списка или полностью его очистить:123 , "bletch" , "xyzzy" , 1234 ] >>> # Вставим (копию) самого себя в начало >>> a[ :0 ] = a >>> a [ 123 , "bletch" , "xyzzy" , 1234 , 123 , "bletch" , "xyzzy" , 1234 ] >>> # Очистка списка: замена всех значений пустым списком >>> a[ :] = >>> a

Встроенная функция len() также применима к спискам:

>>> a = [ "a" , "b" , "c" , "d" 1 ] .append ("xtra" ) >>> p [ 1 , [ 2 , 3 , "xtra" ] , 4 ] >>> q [ 2 , 3 , "xtra" ]

Обратите внимание, что в последнем примере p и q на самом деле ссылаются на один и тот же объект! Мы вернёмся к семантике объектов позже.

Первые шаги к программированию

Безусловно, Python можно использовать для более сложных задач, чем сложение двух чисел. Например, мы можем вывести начало последовательности чисел Фибоначчи таким образом:

>>> # Ряд Фибоначчи: ... # сумма двух элементов определяет следущий элемент ... a , b = 0, 1 >>> while b < 10: ... print (b) ... a , b = b, a+b ... 1 1 2 3 5 8

Этот пример показывает нам некоторые новые возможности.

• Первая строка содержит множественное присваивание (multiple assignment): переменные a и b параллельно получают новые значения - 0 и 1 . В последней строке этот метод используется снова, демонстрируя тот факт, что выражения по правую сторону [от оператора присваивания] всегда вычисляются раньше каких бы то ни было присваиваний. Сами же разделённые запятыми выражения вычисляются слева направо.

• Цикл while (пока) исполняется до тех пор, пока условие (здесь: b < 10) остается истиной. В Python, также как и в C, любое ненулевое значение является истиной (True); ноль является ложью (False). Условием может быть строка, список или вообще любая последовательность; все, что имеет ненулевую длину, играет роль истины, пустые последовательности - лжи. Использованная в примере проверка - простое условие. Стандартные операции сравнения записываются так же, как и в C: < (меньше чем), > (больше чем), == (равно), <= (меньше или равно), >= (больше или равно) и!= (не равно).

• Тело цикла выделено отступом (indented). Отступы - это средство группировки операторов в Python. Интерактивный режим Python (пока!) не имеет какого-либо разумного и удобного средства для редактирования строк ввода, поэтому необходимо использовать табуляции или пробелы для отступа в каждой строке. На практике более сложный текст на Python готовится в текстовом редакторе, а большинство из них имеют функцию авто-отступа. По окончанию ввода составного выражения в интерактивном режиме, необходимо закончить его пустой строкой - признаком завершения (поскольку интерпретатор не может угадать, когда вами была введена последняя строка). Обратите внимание, что размер отступа в каждой строке основного блока должен быть одним и тем же.

• Функция print() выводит значения переданных ей выражений. Поведение этой функции отличается от обычного вывода выражения (как происходило выше в примерах с калькулятором) тем, каким способом обрабатываются ряды выражений, величины с плавающей точкой и строки. Строки выводятся без кавычек и между элементами вставляются пробелы, благодаря чему форматирование вывода улучшается - как, например, здесь:
987