Основы

Просто напечатать hello world недостаточно, верно? Вы хотите сделать больше – вы хотите ввести что-то в программу, обработать и получить нечто на выходе. В Python это можно организовать при помощи констант и переменных, а также некоторыми другими способами, которые будут рассмотрены в этой главе.

Комментарии

Комментарии – это то, что пишется после символа #, и представляет интерес лишь как заметка для читающего программу.

Например:

print('hello world') # print - это функция

или:

# print - это функция
print('hello world')

Старайтесь в своих программах писать как можно больше полезных комментариев, объясняющих:

• предположения
• важные решения
• важные детали
• проблемы, которые вы пытаетесь решить
• проблемы, которых вы пытаетесь избежать в вашей программе и т.д.

Текст программы говорит о том, КАК, а комментарии должны объяснять, ПОЧЕМУ.

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

Литеральные константы

Примером литеральной константы может быть число, например, 5, 1.23, или что-нибудь вроде 'This is a string' или "It's a string!".

Они называются литеральными, потому что они буквальны¹ – вы используете их значение буквально. Число 2 всегда представляет само себя и ничего другого – это константа, потому что её значение нельзя изменить. Поэтому всё это называется литеральными константами.

Числа

Числа в Python бывают двух типов: целые и с плавающей точкой.

Примером целого числа является 2, которое представляет собой просто целое число.

Примерами чисел с плавающей точкой (или плавающих для краткости) могут быть 3.23 и 52.3E-4. Обозначение E показывает степени числа 10. В данном случае 52.3E-4 означает 52.3 * 10^-4^

Замечание для опытных программистов

Нет отдельного типа long (длинное целое). Целые числа по умолчанию могут быть произвольной длины.

Строки

Строка – это последовательность символов. Чаще всего строки – это просто некоторые наборы слов.

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

Одинарные кавычки

Строку можно указать, используя одинарные кавычки, как например, 'Фраза в кавычках'.

Все пробелы и знаки табуляции сохранятся, как есть.

Двойные кавычки

Строки в двойных кавычках работают точно так же, как и в одинарных. Например, "What's your name?".

Тройные кавычки

Можно указывать многострочные строки с использованием тройных кавычек (""" или '''). В пределах тройных кавычек можно свободно использовать одинарные и двойные кавычки. Например:

'''Это многострочная строка. Это её первая строка.
Это её вторая строка.
"What's your name?", - спросил я.
Он ответил: "Bond, James Bond."
'''

Строки неизменяемы

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

Замечание для программистов на C/C++

В Python нет отдельного типа данных char (символ). В нём нет нужды, и я уверен, что вы не будете по нему скучать.

Замечание для программистов на Perl/PHP

Помните, что строки в двойных кавычках и в одинарных эквивалентны, и ничем друг от друга не отличаются.

Метод format

Иногда бывает нужно составить строку на основе каких-либо данных. Вот здесь-то и пригождается метод format().

Сохраните следующие строки в файл str_format.py:

age = 20
name = 'Swaroop'

print('Возраст {0} - {1} лет.'.format(name, age))
print('Почему {0} забавляется с этим Python?'.format(name))

Вывод:

$ python str_format.py
Возраст Swaroop - 20 лет.
Почему Swaroop забавляется с этим Python?

Как это работает

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

Взгляните на первый случай применения обозначений, где мы пишем {0}, и это соответствует переменной name, являющейся первым аргументом метода format. Аналогично, второе обозначение {1} соответствует переменной age, являющейся вторым аргументом метода format. Заметьте, что Python начинает отсчёт с 0, поэтому первая позиция – номер 0, вторая – номер 1 и т.д.

Заметьте, мы ведь могли добиться того же самого результата и объединением строк:

'Возраст' + name + ' - ' + str(age) + ' лет.'

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

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

age = 20
name = 'Swaroop'

print('{} было {} лет когда он написал эту книгу'.format(name, age))
print('Почему {} забавляется с этим Python?'.format(name))

и получить такой же результат, как и ранее.

Могут быть и более детальные обозначения, такие как:

age = 20
name = 'Swaroop'

print('{name} было {age} лет когда он написал эту книгу'.format(name=name, age=age))
print('Почему {name} забавляется с этим Python?'.format(name=name))

что даст такой же точный вывод, как и предыдущая программа.

В Python 3.6 появился более короткий способ работы с именованными параметрами, который называется "f-строки":

age = 20
name = 'Swaroop'

print(f'{name} было {age} лет когда он написал эту книгу')  # заметьте 'f' идет перед строкой
print(f'Почему {name} забавляется с этим Python?')  # заметьте 'f' идет перед строкой

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

Что делает Python в методе format, так это подставляет значение каждого аргумента на место спецификации. Могут быть более подробные спецификации, такие как:

# десятичное число (.) с точностью в 3 знака для плавающих '0.333'
print('{0:.3}'.format(1/3))
# заполнить подчёркиваниями (_) с центровкой текста (^) по ширине 11 '___hello___'
print('{0:_^11}'.format('hello'))
# по ключевым словам 'Swaroop написал A Byte of Python'
print('{name} написал {book}'.format(name='Swaroop', book='A Byte of Python'))

Вывод:

0.333
___hello___
Swaroop написал A Byte of Python

Поскольку мы обсуждаем форматирование, обратите внимание, что print всегда завершается невидимым символом "новой строки" (\n), так что повторные вызовы print будут печататься каждый раз на отдельной строке. Чтобы предотвратить печать этого символа новой строки, вы можете указать, что он должен заканчиваться(end) пустой строкой:

# '' или "" - это пустая строка
print('a', end='')
print('b', end='')

Вывод:

ab

Или вы можете закончить пробелом:

print('a', end=' ')
print('b', end=' ')
print('c')

Вывод:

a b c

Управляющие последовательности

Предположим, у вас есть строка, содержащая одинарную кавычку ('), как вы зададите эту строку? Например, строка "What's your name?". Вы не можете указать 'What's your name?', потому что Python запутается, где начинается и заканчивается строка. Поэтому нужно указать, что эта одинарная кавычка не обозначает конец строки. Это можно сделать с помощью так называемой управляющей последовательности или escape последовательности. Вы указываете одинарную кавычку как \': обратите внимание на обратную косую черту. Теперь вы можете указать строку как 'What\'s your name?'.

Другим способом указать эту конкретную строку было бы "What's your name?", т.е. используя двойные кавычки. Аналогично, для использования двойной кавычки в строке с двойными кавычками необходимо использовать управляющую последовательность. Кроме того, вы должны указать обратную косую черту, используя последовательность \\.

Что если вы хотите указать двухстрочную строку? Можно использовать тройные кавычки, как показано ранее, или использовать управляющую последовательность для символа новой строки - \n, чтобы указать начало новой строки. Пример:

'Это первая строка\nЭто вторая строка'

Еще одна полезная последовательность, которую необходимо знать, - это табуляция: \t. Существует еще много других экранирующих последовательностей, но я упомянул здесь только самые полезные из них.

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

"Это первое предложение. \
Это второе предложение."

эквивалентно

"Это первое предложение. Это второе предложение".

Необработанная строка

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

r"Новые строки обозначаются \n"

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

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

Переменные

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

Имена идентификаторов

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

• Первым символом идентификатора должна быть буква из алфавита (символ ASCII в верхнем или нижнем регистре, или символ Unicode), а также символ подчёркивания (_).
• Остальная часть идентификатора может состоять из букв (символы ASCII в верхнем или нижнем регистре, а также символы Unicode), знаков подчёркивания (_) или цифр (0-9).
• Имена идентификаторов чувствительны к регистру. Например, myname и myName – это не одно и то же. Обратите внимание на n в нижнем регистре в первом случае и N в верхнем во втором.
• Примеры допустимых имён идентификаторов: i, name_2_3. Примеры недопустимых имён идентификаторов: 2things, this is spaced out, my-name and >a1b2_c3.

Типы данных

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

Объекты

Помните, Python рассматривает всё, что есть в программе, как объекты. Имеется в виду, в самом общем смысле. Вместо того, чтобы говорить что-то, мы говорим объект.

Замечание для программистов в объектно-ориентированном стиле:

Python строго объектно ориентирован в том смысле, что объектом является всё, включая числа, строки и функции.

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

Как писать программы на Python

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

Для PyCharm

1. Откройте PyCharm.
2. Создайте новый файл с указанным именем.
3. Введите текст программы из примера.
4. Щелкните правой кнопкой мыши и запустите текущий файл.

ПРИМЕЧАНИЕ: Если вам необходимо предоставить аргументы командной строки, нажмите Run -> Edit Configurations и введите аргументы в разделе Script parameters: и нажмите кнопку OK:

Для других редакторов

1. Откройте выбранный вами редактор.
2. Введите код программы, приведенный в примере.
3. Сохраните его в виде файла с указанным именем.
4. Запустите интерпретатор командой python program.py для выполнения программы.

Пример: Использование переменных и констант

Введите и запустите следующую программу:

# Имя файла : var.py
i = 5
print(i)
i = i + 1
print(i)

s = '''Это многострочная строка.
Это вторая её строчка.'''
print(s)

Вывод:

5
6
Это многострочная строка.
Это вторая её строчка.

Как это работает

Вот как эта программа работает. Сперва мы присваиваем значение константы 5 переменной i, используя оператор присваивания (=). Эта строка называется предложением и указывает, что должно быть произведено некоторое действие, и в данном случае мы связываем имя переменной i со значением 5. Затем мы печатаем значение i, используя функцию print, которая просто печатает значение переменной на экране.

Далее мы добавляем 1 к значению, хранящемуся в i и сохраняем его там. После этого мы печатаем его и получаем значение 6, что неудивительно.

Аналогичным образом мы присваиваем строковую константу переменной s, после чего печатаем её.

Замечание для программистов на статических языках программирования

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

Логические и физические строки

Физическая строка – это то, что вы видите, когда набираете программу. Логическая строка – это то, что Python видит как единое предложение. Python неявно предполагает, что каждой физической строке соответствует логическая строка.

Примером логической строки может служить предложение print('hello world') – если оно на одной строке (как вы видите это в редакторе), то эта строка также соответствует физической строке.

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

Чтобы записать более одной логической строки на одной физической строке, вам придётся явно указать это при помощи точки с запятой (;), которая отмечает конец логической строки/предложения. Например,

i = 5
print(i)

то же самое, что

i = 5;
print(i);

и то же самое может быть записано в виде

i = 5; print(i);

или даже

i = 5; print(i)

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

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

s = 'Это строка. \
Это строка продолжается.'
print(s)

Вывод:

Это строка. Это строка продолжается.

Аналогично,

i = \
5

то же самое, что и

i = 5

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

Отступы

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

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

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

i = 5
# Ошибка! Обратите внимание на первый пробел в начале строки
 print('Значение составляет ', i) 
print('Я повторяю, значение составляет ', i)

Когда вы запустите это, вы получите следующую ошибку:

  File "whitespace.py", line 3
    print('Value is', i)
    ^
IndentationError: unexpected indent

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

Как отступать

Используйте четыре пробела для отступов. Это официальная рекомендация языка Python. Хорошие редакторы автоматически делают это за вас. Убедитесь, что вы используете одинаковое количество пробелов для отступов, иначе ваша программа не будет выполняться или будет иметь неожиданное поведение.

Замечание для программистов на статических языках программирования

Python всегда будет использовать отступы для выделения блоков и никогда не будет использовать скобки. Введите from future import braces, чтобы узнать больше.

Резюме

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

¹. "literal" – англ. "буквальный"; вспомните "литера" (син. "буква"). (прим. перев.) ↩