2. Переменные и простые типы данных

 

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

Что происходит при запуске hello_world.py

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

hello_world.py

print("Hello Python world!")

При выполнении этого кода выводится следующий текст:

Hello Python world!

Суффикс .py в имени файла hello_world.py указывает, что файл является программой Python. Редактор запускает файл в интерпретаторе Python, который читает программу и определяет, что означает каждое слово в программе. Например, обнаружив слово print, за которым следуют круглые скобки, интерпретатор выводит на экран текст, находящийся внутри них.

Когда вы пишете программу, редактор выделяет цветом разные ее части. Например, он понимает, что print() — имя функции, и выделяет это слово одним цветом. А текст Hello Python world! не является кодом Python, поэтому выделяется другим цветом. Этот механизм, называемый цветовым выделением синтаксических элементов (syntax highlighting), очень поможет вам, когда вы начнете писать собственные программы.

Переменные

Попробуем использовать переменную в программе hello_world.py. Добавьте новую строку в начало файла и измените вторую строку:

hello_world.py

message = "Hello Python world!"

print(message)

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

Hello Python world!

Вы добавили в программу переменную message. В каждой переменной хранится значение, то есть связанные с ней данные. В нашем случае значением является текст "Hello Python world!".

Добавление переменной немного усложняет задачу интерпретатора Python. Во время обработки первой строки он связывает текст "Hello Python world!" с переменной message. А добравшись до второй строки, выводит на экран значение, связанное с именем message.

Немного расширим программу hello_world.py, чтобы она выводила второе сообщение. Добавьте в hello_world.py пустую строку, а после нее еще две строки кода:

message = "Hello Python world!"

print(message)

 

message = "Hello Python Crash Course world!"

print(message)

Теперь при выполнении hello_world.py на экране должны появляться две строки:

Hello Python world!

Hello Python Crash Course world!

Вы можете в любой момент изменить значение переменной в своей программе; Python постоянно отслеживает его текущее состояние.

Выбор имен и использование переменных

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

• Имена переменных могут состоять только из букв, цифр и символов подчеркивания. Они могут начинаться с буквы или символа подчеркивания, но не с цифры. Например, переменной можно присвоить имя message_1, но не 1_message.

• Пробелы в именах переменных запрещены, а для разделения слов в именах переменных используются символы подчеркивания. Например, имя greeting_message допустимо, а имя greeting message вызовет ошибку.

• Не используйте в качестве имен переменных названия функций и ключевые слова Python; иначе говоря, не используйте слова, которые зарезервированы в Python для конкретной цели, — например, слово print (см. раздел «Ключевые слова и встроенные функции Python» приложения А).

• Имена переменных должны быть короткими, но содержательными. Например, имя name лучше n, имя student_name лучше s_n, а имя name_length лучше length_of_persons_name.

• Будьте внимательны при использовании строчной буквы l и прописной буквы O, поскольку они похожи на цифры 1 и 0.

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

ПРИМЕЧАНИЕ

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

Предотвращение ошибок в именах при использовании переменных

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

Для начала напишем код с намеренно внесенной ошибкой. Введите следующий фрагмент (неправильно написанное слово mesage выделено жирным шрифтом):

message = "Hello Python Crash Course reader!"

print(mesage)

Когда в программе происходит ошибка, интерпретатор Python всеми силами старается помочь вам найти ее причину. Если программа не выполняется нормально, интерпретатор предоставляет данные трассировки — информацию о том, в каком месте кода находился интерпретатор при возникновении проблемы. Ниже приведен пример трассировки, которую Python выдает после того, как вы случайно сделали опечатку в имени переменной:

Traceback (most recent call last):

❶   File "hello_world.py", line 2, in <module>

❷     print(mesage)

          ^^^^^^

❸ NameError: name 'mesage' is not defined. Did you mean: 'message'?

В строке ❶ сообщается, что ошибка произошла в строке 2 файла hello_world.py. Интерпретатор выводит номер строки, чтобы вам было проще найти ошибку ❷, и сообщает тип обнаруженной ошибки ❸. В данном случае была обнаружена ошибка в имени, и сообщается, что переменная с указанным именем (mesage) не определена. Другими словами, Python не распознает имя переменной. Обычно такие ошибки возникают в том случае, если вы забыли присвоить значение переменной перед ее использованием или ошиблись при вводе имени. Если Python обнаружит имя переменной, похожее на нераспознанное, то появится запрос, не это ли имя вы хотели использовать.

Конечно, в данном примере в имени переменной во второй строке пропущена буква s. Интерпретатор Python не проверяет код на наличие опечаток, но следит за тем, чтобы имена переменных записывались одинаково. Например, вот что происходит, если имя message будет неправильно записано еще в одном месте кода:

mesage = "Hello Python Crash Course reader!"

print(mesage)

На этот раз программа выполняется успешно!

Hello Python Crash Course reader!

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

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

Переменные как метки

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

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

ПРИМЕЧАНИЕ

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

Строки

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

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

"This is a string."

'This is also a string.'

Это правило позволяет использовать внутренние кавычки и апострофы в строках:

'I told my friend, "Python is my favorite language!"'

"The language 'Python' is named after Monty Python, not the snake."

"One of Python's strengths is its diverse and supportive community."

Рассмотрим некоторые типичные операции со строками.

Изменение регистра в строке с помощью методов

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

name.py

name = "ada lovelace"

print(name.title())

Сохраните файл как name.py и запустите его. Вывод программы должен выглядеть так:

Ada Lovelace

В этом примере в переменной name сохраняется строка, состоящая из букв нижнего регистра "ada lovelace". За именем переменной в функции print() следует вызов метода title(). Метод представляет собой действие, которое Python выполняет с данными. Благодаря точке (.) после name в конструкции name.title() Python получает указание применить метод title() к переменной name. За именем метода всегда следует пара круглых скобок, поскольку методам для выполнения их работы часто требуется дополнительная информация. Она указывается в скобках. Функции title() дополнительная информация не нужна, поэтому в круглых скобках ничего нет.

Метод title()выполняет капитализацию начальных букв каждого слова (переводит их в верхний регистр), тогда как все остальные символы выводятся в нижнем. Например, данная возможность может быть полезна, если в вашей программе входные значения Ada, ADA и ada должны рассматриваться как одно и то же имя и все они должны отображаться в виде Ada.

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

name = "Ada Lovelace"

print(name.upper())

print(name.lower())

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

ADA LOVELACE

ada lovelace

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

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

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

full_name.py

first_name = "ada"

last_name = "lovelace"

❶ full_name = f"{first_name} {last_name}"

print(full_name)

Чтобы вставить значение переменной в строку, поставьте букву f непосредственно перед открывающей кавычкой ❶. Заключите имя (или имена) переменных, которые должны использоваться внутри строки, в фигурные скобки. Python заменит каждую переменную ее значением при выводе строки.

Такие строки называются f-строками. Буква f происходит от слова format, поскольку Python форматирует строку, заменяя имена переменных в фигурных скобках их значениями. Приведенный выше код выводит следующий результат:

ada lovelace

С помощью f-строк можно выполнять много интересных действий. Например, составлять сложные сообщения с информацией, хранящейся в переменных. Рассмотрим пример:

first_name = "ada"

last_name = "lovelace"

full_name = f"{first_name} {last_name}"

❶ print(f"Hello, {full_name.title()}!")

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

Hello, Ada Lovelace!

Кроме того, f-строки можно использовать для составления сообщения, которое затем сохраняется в переменной:

first_name = "ada"

last_name = "lovelace"

full_name = f"{first_name} {last_name}"

❶ message = f"Hello, {full_name.title()}!"

❷ print(message)

Этот код тоже выводит сообщение Hello, Ada Lovelace!, но сохранение текста сообщения в переменной ❶ существенно упрощает финальный вызов функции print() ❷.

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

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

Для добавления в текст табуляции используется комбинация символов \t:

>>> print("Python")

Python

>>> print("\tPython")

    Python

Разрывы строк добавляются с помощью комбинации символов \n:

>>> print("Languages:\nPython\nC\nJavaScript")

Languages:

Python

C

JavaScript

Табуляции и разрывы строк могут стоять в одной строке. Так, благодаря последовательности "\n\t" Python получает указание начать текст с новой строки, в начале которой располагается табуляция. В следующем примере показано, как использовать одну строку кода для создания четырех строк вывода:

>>> print("Languages:\n\tPython\n\tC\n\tJavaScript")

Languages:

    Python

    C

    JavaScript

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

Удаление пробельных символов

Лишние пробельные символы могут вызвать путаницу в программах. Для человека строки 'python' и 'python ' внешне неотличимы, но для программы это совершенно разные строки. Python видит лишний пробел в 'python ' и считает, что он действительно важен, — до тех пор пока вы не сообщите о противоположном.

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

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

❶ >>> favorite_language = 'python '

❷ >>> favorite_language

'python '

❸ >>> favorite_language.rstrip()

'python'

❹ >>> favorite_language

'python '

Значение, хранящееся в переменной favorite_language ❶, содержит лишний пробел в конце строки. Выводя это значение в терминальном сеансе Python, вы видите пробел в конце значения ❷. Когда метод rstrip() работает с переменной favorite_language ❸, этот лишний символ удаляется. Впрочем, удаление временное — если вы снова запросите значение favorite_language, то увидите, что строка совпадает с исходной, включая лишний пробельный символ ❹.

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

>>> favorite_language = 'python '

❶ >>> favorite_language = favorite_language.rstrip()

>>> favorite_language

'python'

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

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

❶ >>> favorite_language = ' python '

❷ >>> favorite_language.rstrip()

' python'

❸ >>> favorite_language.lstrip()

'python '

❹ >>> favorite_language.strip()

'python'

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

Удаление префиксов

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

>>> nostarch_url = 'https://nostarch.com'

>>> nostarch_url.removeprefix('https://')

'nostarch.com'

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

Как и в случае удаления пробельных символов, метод removeprefix() не изменяет исходную строку. Если вы хотите сохранить в переменной новое значение с удаленным префиксом, то присвойте его либо исходной, либо новой переменной:

>>> simple_url = nostarch_url.removeprefix('https://')

Если в адресной строке браузера URL отображается без префикса https://, то, вероятно, «за кадром» используется метод, подобный removeprefix().

Предотвращение синтаксических ошибок в строках

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

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

apostrophe.py

message = "One of Python's strengths is its diverse community."

print(message)

Апостроф находится в строке, заключенной в двойные кавычки, так что у интерпретатора Python не возникает проблем с правильным пониманием следующей строки:

One of Python's strengths is its diverse community.

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

message = 'One of Python's strengths is its diverse community.'

print(message)

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

  File "apostrophe.py", line 1

    message = 'One of Python's strengths is its diverse community.'

                                                                ❶ ^

SyntaxError: unterminated string literal (detected at line 1)

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

ПРИМЕЧАНИЕ

Функция цветового выделения синтаксических элементов ускоряет выявление некоторых синтаксических ошибок прямо во время написания программы. Если вы увидите, что код Python выделяется как обычный текст (или обычный текст выделяется как код Python), то, скорее всего, в вашем файле где-то пропущена кавычка.

Числа

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

Целые числа

В Python с целыми числами можно выполнять операции сложения (+), вычитания (–), умножения (*) и деления (/).

>>> 2 + 3

5

>>> 3 - 2

1

>>> 2 * 3

6

>>> 3 / 2

1.5

В терминальном сеансе Python просто возвращает результат операции. Для представления операции возведения в степень в Python используется сдвоенный знак умножения:

>>> 3 ** 2

9

>>> 3 ** 3

27

>>> 10 ** 6

1000000

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

>>> 2 + 3*4

14

>>> (2 + 3) * 4

20

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

Вещественные числа

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

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

>>> 0.1 + 0.1

0.2

>>> 0.2 + 0.2

0.4

>>> 2 * 0.1

0.2

>>> 2 * 0.2

0.4

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

>>> 0.2 + 0.1

0.30000000000000004

>>> 3 * 0.1

0.30000000000000004

Нечто подобное может произойти в любом языке; для беспокойства нет причин. Python пытается подобрать как можно более точное представление результата, что иногда бывает нелегко из-за особенностей внутреннего представления чисел в компьютерах. Пока просто не обращайте внимания на «лишние» разряды; вы узнаете, как поступать в подобных ситуациях, когда эта проблема станет актуальной для вас в проектах части II.

Целые и вещественные числа

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

>>> 4/2

2.0

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

>>> 1 + 2.0

3.0

>>> 2 * 3.0

6.0

>>> 3.0 ** 2

9.0

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

Символы подчеркивания в числах

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

>>> universe_age = 14_000_000_000

При выводе числа, определяемого с помощью символов подчеркивания, Python выводит только цифры:

>>> print(universe_age)

14000000000

Python игнорирует символы подчеркивания при хранении таких значений. Даже если цифры не группируются в тройках, это никак не повлияет на значение. С точки зрения Python 1000 ничем не отличается от записи 1_000, которая эквивалентна 10_00. Этот вариант записи работает как для целых, так и для вещественных чисел.

Множественное присваивание

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

Например, следующая строка инициализирует переменные x, y и z нулями:

>>> x, y, z = 0, 0, 0

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

Константы

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

MAX_CONNECTIONS = 5000

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

Комментарии

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

Как создаются комментарии

В языке Python признаком комментария является символ «решетка» (#). Интерпретатор Python игнорирует все символы, следующие в коде после # до конца строки. Пример:

comment.py

# Поздороваться со всеми.

print("Hello Python people!")

Python игнорирует первую строку и выполняет вторую.

Hello Python people!

Какие комментарии следует писать

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

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

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

Дзен Python

Опытные программисты Python рекомендуют избегать лишних сложностей и по возможности выбирать простые решения там, где это возможно. Философия сообщества Python выражена в очерке Тима Питерса The Zen of Python («Дзен Python»). Чтобы получить доступ к этому краткому набору принципов написания хорошего кода Python, введите команду import this в интерпретаторе. Я не стану цитировать здесь все принципы, но приведу несколько строк, чтобы вы поняли, почему они важны для вас как начинающего программиста Python.

>>> import this

The Zen of Python, by Tim Peters

Красивое лучше, чем уродливое.

Программисты Python считают, что код может быть красивым и элегантным. В программировании люди занимаются решением задач. Программисты всегда ценили хорошо спроектированные, эффективные и даже красивые решения. Со временем вы больше узнаете о Python, начнете писать больше кода — и когда-нибудь ваш коллега посмотрит на экран вашего компьютера и скажет: «Ого, какой красивый код!»

Простое лучше, чем сложное.

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

Сложное лучше, чем запутанное.

Реальность создает свои сложности; иногда простое решение задачи невозможно. В таком случае используйте самое простое решение, которое работает.

Удобочитаемость имеет значение.

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

Должен существовать один — и желательно, только один — очевидный способ сделать это.

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

Сейчас лучше, чем никогда.

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

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

Резюме

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

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

Отправить