Синтаксис в Python
Чтобы начать писать даже простейшие программы на языке Python (и не только на нем), необходимо изучить хотя бы первичные основы синтаксиса языка. В противном случае компьютер просто не сможет понять и правильно выполнить нашу программу. Например, если строку кода print(‘Привет, Мир!’) из задания предыдущего параграфа записать в виде print (‘Привет, Мир!’) , интерпретатор выдаст ошибку и не выведет это приветствие на экран, т.к. в инструкции мы неправильно употребили пробел. Казалось бы мелочь, но его там вообще быть не должно. Таковы правила синтаксиса языка Python .
– это набор правил, которые определяют структуру и порядок написания программ на этом языке.
Говоря о синтаксисе, мы подразумеваем правила написания идентификаторов и литералов, использования ключевых слов, разделения и оформления инструкций и комментариев и т.д. Уверенное знание всех этих правил, позволит нам писать программы любой сложности, допуская при этом минимум ошибок. А учитывая простоту и лаконичность синтаксиса Python , сделать это будет совсем не трудно. Но прежде, для расширения кругозора, давайте познакомимся с понятиями лексемы и литерала.
Лексемы и литералы в Python
Если синтаксис – это набор правил, которые помогают нам (программистам) правильно писать инструкции, то лексемы — это кирпичики, из которых мы эти инструкции составляем.
– это минимальная единица кода программы, которая имеет для интерпретатора определенный смысл и не может быть разбита на более мелкие логические части.
Все лексемы в Python делятся на пять основных групп: идентификаторы и ключевые слова ( NAME ), литералы ( NUMBER, STRING и т.д.) , символы операций ( OP ), разделители ( NEWLINE, INDENT, ENDMARKER и др.) и комментарии ( COMMENT ).
Узнать из каких лексем состоит тот или иной участок исходного кода Python можно при помощи модуля лексического сканера tokenize, который можно найти в стандартной библиотеке в разделе Python Language Services . После получения списка лексем, его можно использовать, например, для синтаксической подсветки кода на языке Python , логического разбора кода или каких-нибудь других целей.
Для того, чтобы необходимый модуль библиотеки стал доступен для использования в скрипте, его нужно сперва к нему подключить, т.е. . Делается это при помощи ключевого слова import , после которого через пробел указывается требуемый модуль. В нашем случае инструкция импорта может выглядеть как import tokenize .
Чтобы получить наглядное представление о лексемах, давайте рассмотрим пример №1 , в котором представлен код простейшей программы, разбивающей строку с исходным python -кодом на лексемы и выводящей их на экран (для просмотра результата работы программы не забудьте нажать кнопку «Результат» ).
Пример №1. Разложение python-кода на лексемы.
Что касается термина токен , то это та же самая лексема, только с указанием ее местонахождения в исходном коде. Дело в том, что лексические сканеры обычно выделяют не только сами лексемы, но также номера строк и столбцов, где каждая лексема начинается и заканчивается.
– это набор из лексемы и ее координат в исходном коде языка программирования.
Теперь давайте скажем пару слов о литералах. Термин этот мы уже встречали, осталось понять, что они из себя представляют.
– это простые неименованные значения некоторого типа данных, написанные непосредственно в самом коде программы.
В качестве примеров приведем литералы, которые являются значениями различных типов данных: вещественное число 3.4 , целое число 5 , комплексное число 5+3j , строка в двойных кавычках «яблоко» , строка в одинарных кавычках ‘две груши’ , логические значения True и False , словарь <1: 1, 'два': 2>, список [1, 2, 3] и т.д. При этом, если, например, литерал числа 28840.0303178 является одновременно и лексемой (пусть и выглядит она подозрительно большой), то литерал списка [1, 2] состоит сразу из пяти лексем.
Итак, лексемы – это логически неделимые фрагменты кода, а литералы – обычные значения.
Имена в Python
– это просто имена (например, переменных, функций или классов). В Python идентификаторы чувствительны к регистру символов, должны начинаться с буквы любого алфавита в Юникоде или символа подчеркивания ( _ ), после чего могут следовать любые буквы, цифры или символы подчеркивания. При этом с цифры имена начинаться не должны, иначе интерпретатор не сможет отличить их от чисел.
Примерами идентификаторов могут служить: b (латинская буква), ж (русская буква), _b (начинается со знака подчеркивания), py_2 (включает цифру), _Чаво (начинается со знака подчеркивания и включает русские буквы, одна из которых заглавная), G123 (начинается с заглавной буквы), set_name (имя в «змеиной» нотации), setName (имя в «верблюжей» нотации), ClassName (стиль CupWords ) и т.д.
В то же время комбинации символов 15var_1 , $Var2 или var 3 не могут использоваться в качестве идентификаторов, т.к. они начинаются либо содержат недопустимые символы (третье имя содержит пробел). Также следует помнить про регистр используемых символов, поскольку, например, идентификаторы var_1 , Var_1 и VAR_1 обозначают имена совершенно разных переменных или функций, т.к. регистр символов у них не совпадает.
Для лучшего восприятия кода следует давать именам понятные и по возможности краткие названия, которые бы соответствовали, например, хранящимся в переменных данным или же выполняемым функциями действиям. Кроме того, идентификаторы могут состоять как из одной буквы, так и сразу из нескольких слов. Для таких случаев в программировании существуют два распространенных устоявшихся стиля записи идентификаторов, которые называются («верблюжьяНотация») и («змеиная_нотация»). Если идентификатор состоит из одного слова, то в обоих случаях он пишется строчными буквами. При наличии двух и более слов, в верблюжей нотации первое слово идентификатора пишется строчными буквами, а каждое последующее слово начинается с заглавной буквы. В змеиной нотации все слова пишутся строчными буквами, но каждое последующее слово идентификатора отделяется от предыдущего знаком подчеркивания (см. пример №2 ).
Пример №2. Стили записи идентификаторов.
Обычно программисты сами решают, какой стиль записи имен использовать в своих программах (если конечно не приходится подчиняться общепринятым правилам компании или проекта). Более того, никто не запрещает смешивать сразу оба стиля. Главное помнить, что в плане восприятия так поступать не рекомендуется.
Что касается соглашений по именам в Python , то они подробно описаны в руководстве по написанию кода PEP8 на официальном сайте.
Отступы и точка с запятой в Python
В отличие от многих других языков программирования в Python каждая (команда на языке Python ) обычно отделяется от других не точкой с запятой ( ; ), а переводом строки. Общее правило в Python гласит, что конец строки автоматически считается концом инструкции, находящейся в этой строке. В свою очередь это правило порождает другое, которое предписывает (за редким исключением) писать в каждой строке по одной инструкции (см. пример №3 ).
Пример №3. Примеры разделения инструкций в Python.
Другим важным отличием языка Python является то, что вложенные инструкции одного уровня должны оформляться одинаковыми отступами от левого края. Именно по величине отступов интерпретатор определяет, где заканчивается очередной блок инструкций и начинается новый. Общий шаблон оформления составных (вложенных) инструкций имеет вид:
Неважно, какие отступы мы будем использовать, главное, чтобы для инструкций одного уровня вложенности они были одинаковыми (см. пример №4 ). Так это могут быть символы табуляции или несколько подряд идущих пробелов, но что-то одно в пределах одного блока инструкций.
Пример №4. Порядок использования отступов в Python.
Если бы в примере выше мы использовали для первой вложенной инструкции символ табуляции, а для второй или третьей символы пробела, интерпретатор выдал бы нам ошибку. При этом визуально отступы могли бы выглядеть одинаковыми! Такое может быть при равенстве длины символа табуляции использованному количеству пробелов. Поэтому следует выбрать для себя какой-то один вариант расстановки отступов, чтобы в дальнейшем не путаться. К слову, в официальной документации советуется использовать четыре подряд идущих пробела (см. здесь).
Как и в большинстве других языков программирования в Python присутствует условная инструкция if , которая в общем случае имеет следующий формат записи:
Если первое условие истинно (результатом вычислений будет True ), то выполняется первый блок инструкций. Если первое условие ложно (результатом вычислений будет False ), то проверяются по-очереди все условия необязательных блоков elif и, если найдется истинное условие, то выполняется соответствующий условию блок инструкций. Если все дополнительные условия окажутся ложными, выполнится запасной блок инструкций else . Обязательным является только блок инструкций if , остальные блоки могут быть опущены. При этом разрешается использовать любое количество блоков elif , но только один блок else (еще раз посмотрите на пример выше).
Мы обязательно вернемся к более детальному рассмотрению этой условной инструкции. Пока же просто будем иметь о ней некоторое представление. Тоже самое касается и другой новой информации подаваемой в блоках с зеленой левой границей.
Далее. Бывают ситуации, когда в коде короткие инструкции идут одна за другой. Тогда некоторые программисты записывают их на одной строке, разделяя точкой с запятой. Кроме того, на одной строке с основной инструкцией разрешается записывать и односторочные вложенные инструкции (см. пример №5 ). Однако все это пусть и допускается, но в Python не приветствуется!
Пример №5. Запись нескольких инструкций на одной строке.
Обратите внимание, что когда мы записывали вложенную инструкцию на одной строке с основной, точку с запятой мы не ставили. А вот две вложенные инструкции, расположенные на одной строке, мы, во избежание ошибки, точкой с запятой разделили.
Итак, мы выяснили, что инструкции в Python следует записывать по одной на каждой строке. При этом использовать точку с запятой не нужно, т.к. конец строки автоматически завершает текущую инструкцию. Но что, если инструкция получается слишком длинной и не помещается полностью на экране? В этом случае можно расположить ее на нескольких строках, заключив в зависимости от ситуации в пару круглых, квадратных или фигурных скобок (см. пример №6 ).
Пример №6. Запись одной инструкции на нескольких строках.
Вообще, в официальном руководстве советуют использовать строки кода с длиной не более 79 символов. Поэтому, если ситуация выходит из-под контроля, необходимо не задумываясь применять для переноса длинных строк скобки. Сложностей с выбором подходящего вида скобок возникать не должно, т.к. для каждой синтаксической конструкции предусмотрен свой тип скобок. Например, если мы при помощи литерала объявляем список или словарь, то автоматически подразумеваем квадратные и, соответственно, фигурные скобки. А вот синтаксис вызова функции или литерала кортежа требует от нас использования круглых скобок. Все эти знания приходят со временем и начинают казаться чем-то само собой разумеющимся.
Как вы уже поняли, для вывода информации на экран используется встроенная функция print() , которой через запятую следует передавать выводимые на экран значения. Отметим, что все значения сначала автоматически преобразуются в строки и только потом выводятся. При этом в качестве дополнительных аргументов функции можно передавать именованные строковые аргументы sep и end . Первый задает вид разделителя между выводимыми значениями (по умолчанию это обычный пробел, т.е. sep=’ ‘ ), а второй – символы в конце вывода (по умолчанию это символ перевода строки, т.е. end=’\n’ ). В итоге инструкция вывода, например, двух значений может иметь такой вид: print(‘один’, ‘два’, sep=’ ‘, end=’\n’) .
Комментарии в Python
Еще одной важной частью синтаксиса любого языка программирования являются комментарии. В Python используются только однострочные комментарии, которые начинаются с символа # . Комментарии идут только до конца строки и весь код после символа # интерпретатором игнорируется (см. пример №7 ). При этом принято записывать комментарии на отдельной строке до инструкции, а не вставлять их после в той же строке.
Пример №7. Комментарии в Python.
Многострочные комментарии синтаксисом Python не предусмотрены. Вместо них используются подряд идущие однострочные комментарии. Однако многие программисты, как показано в примере, используют для создания многострочных комментариев строки в тройных кавычках. В результате такого хака многострочные комментарии представляют собой любой текст, расположенный между комбинациями символов »’ и »’ или же «»» и «»» . Такие многострочные комментарии поглощают однострочные, могут содержать несколько строк, но при этом не могут быть вложенными друг в друга.
Текст комментариев интерпретатором игнорируется, но их наличие в исходном коде переоценить практически невозможно. Ведь любой программист на собственном опыте знает, что по прошествии определенного времени разобраться даже в собственном коде становится все сложнее. Поэтому в процессе разработки программ нужно обязательно использовать комментарии, которые позволяют:
- освежить в памяти программиста различные мелкие детали;
- подсказывают, какую задачу решает тот или иной фрагмент кода, в особенности, если код чужой;
- позволяют в случае необходимости временно закомментировать фрагмент кода, например, во время отладки программы;
- играют роль предупреждений, например, о необходимости применения именно данного решения, а не на первый взгляд более очевидного.
Следует помнить, что при внесении в исходный код изменений необходимо одновременно обновлять и комментарии! Иначе рано или позно возникнет неразбериха, в которой код будет выполнять одно, а комментарии подразумевать совсем другое.
В любом случае, правильно составленные комментарии ускоряют как разработку кода, так и его отладку в дальнейшем.
Форматирование python-кода
Если вы еще не посетили официальную страницу руководства PEP8 по написанию кода на Python , сделайте это сейчас хотя бы для ознакомления. Здесь же мы еще раз кратко пройдемся по основным принципам форматирования python -кода, заполнив при этом некоторые пробелы. Итак.
- На каждой строке следует писать по одной инструкции, не вставляя в конце точку с запятой.
- После основной инструкции должно присутствовать двоеточие. При этом одинаковые блоки вложенных инструкций должны отделяться с левой стороны идентичными отступами. В идеале для этого нужно использовать по четыре пробела на каждый уровень вложенности.
- Строки кода по возможности должны полностью помещаться в видимой области экрана монитора. В идеале они не должны превышать длины в 79 символов. Для переноса длинных инструкций на новую строку в зависимости от ситуации следует использовать круглые, квадратные или фигурные скобки.
- В большинстве случаев интерпретатор игнорирует подряд идущие пробелы и символы табуляции (отступы сюда не относятся. ). Поэтому для визуального разделения некоторых лексем и повышения читабельности кода можно смело использовать пробелы (см. пример №8 ). Однако при этом желательно придерживаться устоявшихся стандартов и, например, не ставить подряд несколько пробелов, а также не использовать для таких целей символы табуляции.
- Комментарии в исходном коде следует писать на отдельной строке, а не вместе с инструкцией на одной строке. При этом принято отделять символ решетки от текста комментария пробелом, а предложения начинать с заглавной буквы и завершать точкой.
Пример №8. Примеры использования пробелов в коде Python.
Пугаться такого количества рекомендаций не стоит. Большинство из них в скором времени станут для вас естественным способом оформления кода. А некоторые рекомендации вы и вовсе будете игнорировать, где-то умышленно, а где-то и рефлекторно. Я, например, не люблю ставить пробел в начале комментариев, часто забываю завершать их точкой. Также я привык не отделять пробелами операторы присваивания, ставить их после запятых и т.д. Но придерживаться рекомендаций по оформлению кода в Python все-таки стоит. Не нужно перенимать вредные привычки, ведь потом от них будет очень трудно избавиться.
Вопросы и задания для самоконтроля
1. Что такое синтаксис языка программирования? Показать решение.
Ответ. – это набор правил, которые определяют структуру и порядок написания программ на этом языке.
2. Какие из представленных фрагментов кода являются литералами: «a==5» , d = 0.5 , [0.5, ‘cat’] , <'color': 'green'>, import math , ‘Синий иней’ . Показать решение.
Ответ. «a==5» – литерал строки в двойных кавычках, [0.5, ‘cat’] – литерал списка, <'color': 'green'>– литерал словаря, ‘Синий иней’ – литерал строки в одинарных кавычках.
3. Опишите правила составления имен (идентификаторов) в Python . Показать решение.
Ответ. В Python идентификаторы чувствительны к регистру символов, должны начинаться с буквы любого алфавита в Юникоде или знака подчеркивания _ , после чего могут следовать любые буквы, цифры или символы подчеркивания. При этом с цифры имена начинаться не должны, иначе интерпретатор не сможет отличить их от чисел.
4. Перечислите правильно составленные идентификаторы, сопровождая свой выбор пояснениями: f , f2 , d5 , 3d , abc , ABC , $h , h$2 , _h___2 , h_2_ , 2_h , ruEn , d3.f3 , d3_f3 , d3 f3 , эй_Hey , свободный_дом2 , ухТы. , 3дом_слева , F15 , gggggggggg , d’25’ , s_8 . Показать решение.
Ответ. Правильно составленными являются идентификаторы (см. правила составления имен): f , f2 , d5 , abc , ABC , _h___2 , h_2_ , ruEn , d3_f3 , эй_Hey , свободный_дом2 , F15 , gggggggggg , s_8 .
5. Составьте имя переменной в верблюжей и змеиной нотациях, используя фразу show must go on . Показать решение.
Ответ. Имя переменной в верблюжей нотации будет иметь вид showMustGoOn , а при использовании змеиной нотации – show_must_go_on .
6. Какой символ используется в Python для обозначения комментариев? Определите в коде строки комментариев и закомментируйте их. Показать решение.
Типы данных в Python
Тип данных определяет, что может храниться внутри переменной. Например:
Здесь 24 (целое число) присваивается переменной num . Таким образом, тип данных num относится к классу int .
Типы данных в Python
| Тип данных | Класс | Описание |
| Числа | int, float, complex | Содержит числовые значения. |
| Строки | str | Содержит последовательность символов. |
| Списки | list, tuple, range | Содержит последовательность элементов. |
| Словари | dict | Содержит данные в виде пары ключ-значение. |
| Логический | bool | Содержит True или False. |
| Множество | set, frozeenset | Содержит последовательность уникальных элементов. |
Поскольку в Python всё является объектом, типы данных на самом деле являются классами, а переменные — экземплярами (объектами) этих классов.
Числовые типы данных в Python
Числовой тип данных используется для хранения числовых значений. Целые числа, числа типа с плавающей точкой и составные числа попадают в категорию чисел в Python и определяются как int , float и complex .
int — содержит целые числа со знаком неограниченной длины.
float — содержит числа с плавающей десятичной точкой с точностью до 15 знаков после точки.
Мы можем использовать функцию type(), чтобы узнать, к какому классу принадлежит переменная или значение. Например:
Типы данных языка Python
Данные в языке Python делятся на две группы: простые (обозначают единственное значение) и составные (хранят в себе несколько значений). Рассмотрим основные типы данных языка Python.
- Простые типы данных:
- int — целое число.
- float — вещественное (дробное, действительное) число.
- str — строка.
- bool — булевский (логический) тип.
- list — список, изменяемый набор значений, пронумерованных целыми числами, начиная с 0 .
- tuple — кортеж, неизменяемый набор значений, пронумерованных целыми числами, начиная с 0 .
- dict — словарь (ассоциативный массив) — изменяемый набор значений, индексируемый неизменяемыми типами данных (числа, строки, кортежи).
- set — множество — неупорядоченный набор значений без повторений.
Целые числа ( int )
Целые числа могут быть записаны в разных системах счисления. В десятичной форме они записываются как последовательности десятичных цифр. В шестнадцатеричной форме — как последовательности шестнадцатеричных цифр ( 0 … 9 , A … F ), предварённых знаком 0x . Восьмеричные числа — последовательности восьмеричных цифр, начинаются на 0t . Двоичные — начинаются 0b .
Если у операций + , — , * , // , % оба операнда целые, то результат будет целым. Если хотя бы один из операндов вещественный — результат вещественный. Результат операции / всегда вещественный.
Размер целых чисел неограничен. Длина целого числа ограничивается лишь доступной памятью компьютера.
Тип целых чисел в Python называется int . Одновременно, int можно как встроенную функцию, преобразующую свой аргумент в целое число:
Вещественные числа
Вещественные числа в Python моделируют действительные числа в математике. В отличие от целых чисел, вещественные числа имеют ограниченный диапазон и ограниченную точность.
Диапазон от 10 −323 до 10 +308 . Если при расчётах получится меньшее число, то оно представляется как ноль, если большее — произойдёт ошибка переполнения. Точность ограничена ≈15 десятичными знаками после запятой.
Вещественные числа, в отличие от целых, всегда содержат или знак разделителя целой и дробной части (точку, . ), или показатель степени ( e ). Разделителем целой и дробной части является точка, т.к. запятая используется для разделения параметров функции и при построении составных типов данных (массивы, кортежи и т.д.)
Вещественное число может быть записано в показательной форме в виде
которое означает ‹мантисса› ×10 ‹степень› . Примеры:
Класс вещественных чисел в Python называется float , он же — встроенная функция-конструктор, преобразующая свой аргумент к вещественному числу:
Математическая библиотека ( math )
В Python есть библиотека, содержащая основные математические функции, работающие с вещественными числами: тригонометрия, логарифмы и т.д. Называется она math , подключается к программе как
В форме №1 в программе становятся доступными все константы и функции, определённые в библиотеке.
В форме №2 — те, что явно перечислены после ключевого слова import .
В форме №3 — в программе доступен объект math , функции библиотеки доступны как поля и методы этого объекта.
Функции библиотеки можно посмотреть во встроенной документации:
Преобразование между целыми и вещественными числами
Для преобразования, во-первых, можно использовать конструкторы float и int . В библиотеке math есть функции floor , ceil и round . Разобраться с ними самостоятельно.
Функция abs(x)
Функция abs(x) возвращает абсолютное значение числа:
Строки
Строка (класс str ) представляет последовательность печатных знаков. Знаки, которые представляют строки в Python 3, являются символами Юникода, т.е. включают в себя буквы разных алфавитов, цифры, знаки препинания, иероглифы, пиктограммы, математические знаки и эмодзи. В противоположность, в Python 2.7 строки состояли из однобайтовых символов конкретной кодировки (например, кодировки Windows-1251 на Windows в русскоязычной локализации).
Строки занимают промежуточное положение между простыми и составными типами данных. С одной стороны, они хранят несколько значений. А с другой стороны, у этих значений нет собственного типа — операция индексации s[i] возвращает не печатный символ, а строку из одного знака.
Строки — неизменяемый тип данных.
Конструктор строки — функция str , которая для аргумента любого типа построит строку. Если ей передать строку — то вернётся точная копия строки.
Запись строк в программе
Строки записываются в одинарных ‘. ‘ или двойных «. » кавычках. В каких кавычках записывать — это дело принятого стиля программирования. Чаще пишутся одинарные кавычки.
Если строка записана в одинарных кавычках, то внутри можно использовать двойные:
Если в двойных — внутри можно использовать одинарные (апострофы):
Помимо обычных, печатных символов, существуют особые управляющие символы, например, символ перевода строки. Для записи подобных символов используются так называемые escape-последовательности — последовательности знаков, начинающися со знака \ . (Клавиша «\» рядом с Backspace или «Ъ» на клавиатуре, не путать с «/», расположенной между «Ю» и Shift!)
Escape-последовательность значение \\ Собственно, знак \ \n Перевод строки \r Возврат каретки (возврат к началу строчки) \t Знак табуляции (клавиша Tab) \xNN Символ с шестнадцатиричным кодом NN \uNNNN Символ с шестнадцатиричным кодом NNNN \UNNNNNNNN Символ с шестнадцатиричным кодом NNNNNNNN \b Возврат на символ назад при печати \a При печати выдаёт звуковой сигнал \» Двойная кавычка \’ Одинарная кавычка (апостроф) Примеры на \r и \b (нужно запускать в окне консоли, в IDLE не работает):
Другие примеры (работают в IDLE):
Из всех escape-последовательностей чаще всего мы будем пользоваться переводом строки ( \n ), чуть реже табуляцией ( \t ), представлением самого знака \ ( \\ ) и кавычками, чтобы их записывать внутри строк ( \’ , \» ).
Символ перевода строки \n при печати выполняет переход на новую строку.
Одна escape-последовательность представляет 1 символ строки. Например, строка \n\n\n состоит из трёх символов — трёх переводов строки.
Операции, применимые к строке
К строкам применима операция + , выполняющая конкатенацию (склеивание) строк:
Для целых чисел из курса 1 класс известно, что 3×5 = 3+3+3+3+3 (5 раз). В Python это же применимо и к строкам:
Можно использовать сокращённые операторы присваивания:
Строки можно сравнивать при помощи операций отношения, сравнение осуществляется в алфавитном порядке (точнее, по номерам символов в таблице Юникода):
Если одна строка является префиксом другой, то более короткая строка считается меньше.
Для строк есть ещё одна операция отношения — in , проверяет вхождение подстроки
Операция not in противоположна операции in .
К строкам применима встроенная функция len(•) , возвращающая длину строки:
Можно обращаться символу в строке по номеру, используя операцию индексации s[i] , где s — строка, i — индекс или номер символа. Индекс может быть положительным от 0 до len(s)-1 , где len(s) — длина строки (символы строки нумеруются с нуля).
Либо отрицательным от -len(s) до -1 , в этом случае имеется ввиду номер от конца строки. Если индекс отрицательный, например s[-x] , то подразумевается индекс s[len(s)-x] . Т.е. чтобы из отрицательного индекса получить настоящий, нужно его прибавить к длине строки.
Полезные методы строк
Строки, как и другие типы данных Python, являются объектами, и у них есть свои методы. Все методы строк можно получить во встроенной справке:
Некоторые полезные методы:
- s.split() — разбивает строку по пробельным символам,
- s.split(sep) — разбивает строку по указанному разделителю,
- s.join(xs) — объединяет элементы последовательности xs с разделителем s , xs — должна быть последовательностью строк,
- s.startswith(t) , s.endswith(t) — True , если строка s начинается или заканчивается на t ,
- s.find(t) — ищет индекс, начиная с которого подстрока t входит в строку s , -1 , если не найдено.
- s.trim() — удаляет из строки начальные и конечные пробельные символы (пробелы, табуляции, \n , \r ),
- семейство методов, проверяющих содержание — True , когда строка непустая и все символы заданного типа:
- s.isdigit() — все цифры,
- s.isalpha() — все буквы,
- s.isalnum() — все либо буквы, либо цифры,
- s.isspace() — все пробельные символы (пробел, \t , \n , \r ),
- s.ispunct() — все знаки пунктуации и т.д.
Функции chr(n) и ord(n)
Юникод — международный стандарт на кодирование символов. В таблицу Юникода входят символы различных алфавитов, знаки пунктуации, математические символы, управляющие символы ( \n , \t , \r , \b …), смайлики (эмодзи) и так далее.
В таблице Юникода каждому символу сопоставляется его номер, т.н. кодовая точка. Всего в Юникоде возможно 1 114 112 ( 2**20 + 2**16 ), многие из кодовых точек до сих пор не распределены.
Функция chr(n) возвращает символ с кодовой точкой n :
Функция ord(c) возвращает кодовую точку символа c :
UTF-8 — один из способов кодирования символов Юникода в виде последовательности байтов. При данном способе кодирования различным символам Юникода назначаются последовательности длиной от 1 до 4 байтов. Символы, входящие в таблицу ASCII (латинские буквы, десятичные цифры, основные знаки пуктуации) кодируются 1 байтом, греческие и кириллические буквы — двумя, иероглифы и смайлики — 3–4 байтами в зависимости от кода.
Булевский тип ( bool )
Мы о нём уже говорили, когда обсуждали логические выражения, условный оператор и цикл с предусловием ( while ). Конструктор булевского типа — функция bool , принимает любое значение и трактует его как истину или ложь.
Операции с логическим типом and , or , not мы подробно рассматривали ранее.
Функция abs(x) , которая возвращает абсолютное значение числа, как ни странно, применима и для логических значений. Возвращает 1 для истины, 0 для лжи:
Литералы типа bool : True и False .
Списки ( list )
Список — изменяемый контейнер значений, индексируемый целыми числами в диапазоне от 0 до некоторой величины — длины списка.
Литерал списка — элементы списка, перечисленные через запятую в квадратных скобках
Пример:
Это список из 7 значений, которые являются первыми 7 простыми числами.
Конструктор списка — функция list , которая принимает любую итерируемую последовательность и формирует список с этими элементами:
Длину списка можно узнать при помощи встроенной функции len(xs) :
Операции, применимые к списку
Операция индексирования. К элементам списка можно обращаться по номеру, используя квадратные скобки. Нумерация может быть как положительной — от 0 до len(‹список›)−1 , так и отрицательной — от −1 до −len(‹список›) . Положительный индекс позволяет обратиться к элементу, начиная с начала, отрицательный — начиная с конца ( xs[-1] — последний элемент, xs[-len(xs)] — первый элемент). Т.е. тут аналогично со строками:
Но, в отличие от строк, список является изменяемой структурой данных. Обращение к элементу списка может располагаться слева в операторе присваивания:
«Сложение и умножение». Тут тоже похоже на строки: операция + позволяет склеивать два списка:
Операция * , применённая к списку и целому числу, конкатенирует (склеивает) список с собой указанное количество раз:
В примере с ys мы создали список из нулей длины 10. Вообще, это распространённый приём. Если в задаче требуется иметь список чисел заданной длины, заполненный изначально нулями, то просто умножаем список из одного нуля [0] на заданную длину: [0] * n .
К спискам применимы и сокращённые операторы присваивания:
Операция in позволяет узнать, есть ли в списке данное значение:
Полезные методы списков
Самый распространённый метод — xs.append(x) — добавляет элемент в конец списка.
Метод xs.sort() сортирует список на месте. Список можно отсортировать, если к его элементам применимы отношения > , < , >= и т.д., в противном случае получим ошибку.
Список сортируется на месте, т.е. его содержимое изменяется.
Метод xs.count(x) возвращает количество элементов с заданным значением:
Полезные функции, работающие со списками
На самом деле, многие из рассмотренных функций могут работать не только со списками, но и с любыми другими итерируемыми последовательностями, но об этом поговорим позже.
Функция max(xs) возвращает наибольшее значение в списке. Список должен быть не пустым. min(xs) — соответственно, наименьшее значение.
Функция sorted(xs) возвращает новый список со значениями, отсортированными по возрастанию. Исходный список не меняется.
Функция reversed(xs) строит итерируемую последовательность элементов списка в обратном порядке. Чтобы её сделать списком, её нужно передать конструктору list :
Кортежи ( tuple )
Кортеж — неизменяемый контейнер с элементами, нумеруемыми последовательными целыми числами. Используется для группировки нескольких значений в одно.
Конструктор типа — функция tuple , работает аналогично функции list .
Запись кортежей — перечисление элементов через запятую в круглых скобках, иногда снаружи круглые скобки можно опустить:
Чтобы создать кортеж из одного элемента, нужно после него добавить запятую:
Запятая после 1 означает, что это кортеж, а не просто число.
Кортеж можно считать аналогом списка, содержимое которого запрещено изменять:
В программе, как правило, списки используют для представления набора однородных данных (список чисел, список строк, список каких-то объектов) неизвестной длины (длина определяется входными данными), который можно менять. Кортежи используются для представления разнородных данных, они небольшого размера и длина известна программисту на момент написания программы.
Упаковка и распаковка списков и кортежей
Если длина списка или кортежа известна, то его содержимое можно распаковать оператором присваивания. Для этого слева нужно перечислить через запятую столько переменных, сколько элементов в самом контейнере:
Такой приём удобен, если список или кортеж небольшой. Если контейнер справа в операторе присваивания большой, то при помощи распаковки можно выделить несколько значений в начале, в конце, а всё, что между ними — поместить в новый список. Перед переменной, куда будет помещён список, нужно поставить звёздочку:
Переменная со звёздочкой может быть только одна, в эту переменную всегда попадает список, даже если справа находится не список:
Распаковка контейнеров позволяет элегантно обменивать значения двух переменных:
Справа в операторе присваивания строится кортеж (b, a) (скобки тут опущены), который тут же распаковывается.
Возврат нескольких значений из функции
В Python, в отличие от языков типа C++ или Pascal, нет параметров-ссылок, т.е. нет возможности из функции изменить значение переменной, которая передана как параметр:
После вызова other_function переменные a и b будут иметь те же значения, что и до вызова — в a будет лежать число 100 , в b — ссылка на тот же список (хотя содержимое списка может измениться). В Python нет возможности изменить значения переменных из вызванной функции.
Поэтому поступить как в Паскале или C++ — передать параметр по ссылке и изменить его внутри функции, мы не можем.
Единственный способ передать из вызова функции наружу — вернуть значение при помощи return .
Если мы хотим передать из функции несколько значений — нам нужно упаковать их в какой-нибудь контейнер и вернуть контейнер. В качестве такого контейнера чаще всего используют кортеж.
Если в операторе return перечислить через запятую несколько значений, функция вернёт кортеж из этих значений:
Для анализа этих значений можно использовать распаковку
Функция divmod(a, b) выполняет деление с остатком: возвращает частное и остаток.
Срезы строк, списков и кортежей
Ранее мы говорили, что операция индексирования xs[i] позволяет обратиться к одному элементу строки, списка или кортежа. В случае списков, операция индексирования может располагаться в левой части оператора присваивания:
поскольку список является изменяемым типом данных.
Однако, при помощи операции индексирования можно обращаться и целым участкам последовательностей, т.е. списков, строк или кортежей. Это так называемый синтаксис срезов:
- ‹start› — индекс первого элемента среза,
- ‹limit› — индекс граничного элемента среза, т.е. участок от ‹start› до ‹limit› включает в себя ‹start› и не включает в себя ‹limit› . Пользуясь математическими обозначениями, границы можно записать как полуоткрытый интервал [‹start›, ‹limit›) .
- ‹step› — шаг, с которым выбираются элементы.
Каждый из этих компонентов может отсутствовать, в этом случае подразумевается:
- отсутствует ‹start› — подразумевается от начала последовательности,
- отсутствует ‹limit› — до конца последовательности, т.е. до len(xs) ,
- отсутствует ‹step› — шаг равен 1, т.е. элементы перечисляются без пропусков.
Шаг может быть отрицательным — в этом случае элементы перечисляются в обратном порядке. В этом случае ‹start› должен быть больше, чем ‹limit› :
На практике чаще всего используют отрицательный шаг -1 для того, чтобы перевернуть список, кортеж или строку:
Списки являются изменяемой структурой данных, с ними можно использовать присваивания срезам:
А что означает срез xs[:] ? Очевидно, это всё содержимое списка от начала и до конца. Зачем оно нужно? На практике такой срез используется, чтобы получить копию списка.
Дело в том, что список — ссылочный тип данных. Когда мы присваиваем список другой переменной, то у нас копируется только ссылка — обе переменные ссылаются на один и тот же список. Можно сказать, что у одного списка получаются два равноправных псевдонима.
И если теперь поменять значение списка через одну переменную, мы это же изменение увидим через другую:
Переменные xs и ys в примере — два псевдонима для одного объека списка. В этом примере в памяти компьютера находится один список, на который ссылаются переменные xs и ys , можем видеть и менять его содержимое через любую из них.
Во втором примере мы при помощи среза xs[:] создали новый список с тем же содержимым. Т.е. в памяти компьютера образовалось два равных списка, на один ссылается переменная xs , на другой — zs . Через переменную xs мы можем видеть и менять содержимое первого списка, через zs — второго. Изменения обоих списков независимы.
Срез xs[:] может использоваться для изменения содержимого всего списка.
Когда мы присвоили переменной ys новый список, мы просто в неё положили ссылку на новый список. Содержимое списка xs мы не меняли.
Тут мы поменяли содержимое списка, на который ссылаются две переменные xs и ys через переменную ys . Соответственно, т.к. эти переменные — псевдонимы, через xs видно изменение.
Ещё про ссылочные типы данных
В Python все данные — ссылочные. Но для неизменяемых типов ( int , float , str , tuple ) это не важно, т.к. для них копирование ссылки эквивалентно копированию значения.
Для изменяемых типов данных ( list , dict , set ) о том, что данные ссылочные, помнить нужно. Присваивание переменной не создаёт новый список (или словарь, или множество), а просто копирует ссылку на объект, создаёт псевдоним. Изменения, сделанные через один псевдоним, будут видны и через другой. Чтобы создать новый объект и менять его независимо, нужно его явно скопировать. Например, для списка при помощи среза xs[:] .
Частный случай присваивания — присваивания параметрам при вызове функции:
При вызове этой функции содержимое списка будет меняться:
При вызове функции параметру xs была присвоена ссылка на тот же список, что и в переменной ys — а значит, функция изменила чужой список.
Тут мы хитрые, передали в функцию копию списка, функция поменяла содержимое копии, исходный список остался неприкосновенным.
Словари ( dict )
Ранее мы рассматривали последовательности — контейнеры, элементы в которых сопоставлялись последовательным целым числам: от 0 до N−1 или (если ссылаться справа налево) от −1 до −N. К элементам последовательности мы обращаемся по номеру.
Словарь ( dict ) — контейнер, к элементам которого можно обращаться по ключам, например, строкам. Словарь хранит внутри себя пары значений в произвольном порядке. Первый элемент каждой пары называется ключом, второй — значением. Каждому ключу сопоставляется ровно одно значение — ключи повторяться не могут. А значения повторяться могут.
Словарь позволяет находить или изменять значение (второй компонент пары), зная её ключ. Синтаксис тот же, что и при индексации массива:
Т.е. в словаре exam_scores (экзаменационные оценки) с ключом ‘Вася’ мы связали значение 5 , ранее с другим ключом ‘Маша’ было связано значение 4 .
Можно сказать, что ключ — это «имя» для некоторого значения.
Конструктор словаря — функция dict() . Без параметров создаёт пустой словарь, её параметром может быть список пар.
Создать словарь можно, перечислив его содержимое в фигурных скобках. Содержимое записывается как пары ‹ключ› : ‹значение› , перечисленные через запятую. В каждой паре ключ и значения разделяются двоеточием:
Ключами словаря могут служить только неизменяемые значения:
- числа: int , float ,
- строки str ,
- кортежи ( tuple ) из других неизменяемых значений.
Операции со словарями
Обращаться к элементам словаря можно при помощи операции индексации, примеры на которую мы рассмотрели выше:
Объединять значения двух словарей можно при помощи операции | : d1 | d2 , при этом значения из d2 имеют приорирет, т.е. если в обоих словарях есть одинаковые ключи, то значения для них берутся из второго словаря:
Операция del позволяет удалить значение из словаря:
Полезные методы словарей
Метод dict.get() извлекает значение из словаря:
Операция индексации при обращении к несуществующему ключу приводит к ошибке (как и при выходе за границы списка).
Метод get к ошибке не приводит. Если ключа не существует, то возвращается значение по умолчанию default , если default не указан, то подразумевается None :
При помощи метода get можно представлять себе словарь как бесконечный, при этом всем реально не существующим ключам get сопоставляет значение по умолчанию.
Например, если мы посчитываем какие-то значения (например, слова), то можем считать, что для несуществующих слов их количество равно нулю, вызывая words.get(word, 0) .
Пример. Напишем функцию dict_get , имитирующую поведение метода get :
В словаре d_ext заведомо будет нужный ключ, т.к. он получен объединением словаря
с исходным. При этом в операции объединения | исходный словарь указан справа, поэтому если в нём есть искомое значение, то оно перекроет значение default из словаря слева. Если нет, в d_ext останется default для ключа key . Метод items возвращает список (на самом деле, итератор, но о них позже) с парами (‹ключ›, ‹значение›) .
Метод items удобно использовать в цикле for (об этом на следующей лекции).
Метод copy создаёт копию словаря (похож на срез xs[:] для списков).
Множество ( set )
Тип данных «множество» ( set ) хранит неупорядоченный набор значений без повторений. Элементами множества могут быть только неизменяемые типы данных (как и ключи в словаре): числа, строки, кортежи из чисел и строк.
В отличие от списка, данные во множестве неупорядочены — при переборе его содержимого элементы будут просматриваться в произвольном порядке. Т.е. как множество захочет расположить внутри себя элементы, так и расположит, мы на это повлиять никак не можем.
Элементы во множестве не повторяются — если мы попробуем добавить ко множеству элемент, который там присутствует, то множество просто не изменится.
Контструктор и литералы
Конструктор множества — set , может быть вызван без параметров, тогда будет создано пустое множество, может получать на входе некоторый другой контейнер (например, список или строку) — будет построено множество из элементов этого контейнера.
Можно создать множество путём перечисления элементов в фигурных скобках:
В Python фигурные скобки используются в двух ролях: для создания словарей и создания множеств. Разница между ними в том, что при создании словарей указываются ключи:
В переменной xs будет находиться словарь, в переменной ys будет находиться множество. Поскольку мы отличаем создание словаря от создания множества по содержимому фигурных скобок, то пустые фигурные скобки <> могут трактоваться неоднозначно: и как пустой словарь, и как пустое множество.
Поскольку на практике словари используются чаще множеств, разработчики Python решили, что пустые фигурные скобки <> будут представлять пустой словарь. А для создания пустого множества нужно вызывать конструктор set() без параметров.
Основные операции над множествами
Операция in ( not in ) проверяет входит ли (не входит ли) элемент во множество:
Операция | , как и для словарей, строит объединение множеств:
Операция & строит пересечение множеств:
Операция — вычисляет разность множеств:
Для этих операций есть соответствующие сокращёные записи оператора присваивания: |= , &= , -= .
Некоторые методы множеств
Самый основной метод — метод .add(x) , добавляющий элемент во множество:
Метод .remove(x) удаляет элемент из множества. Если его вызвать к отсутствующему элементу, получим ошибку. Для того, чтобы удалить элемент, но при этом не получить ошибку, если он отсутствовал, нужно просто вычесть множество из одного элемента:
Пример применения множеств
Дан список элементов. Составить новый список, в котором отстутсвуют дубликаты, причём порядок не важен. Для этого мы из списка делаем множество, а из него — снова список:
Дан список элементов. Проверить — есть ли в нём дубликаты?
Почему работает эта функция? Потому что если в списке будут дубликаты, то множество, построенное из него, будет содержать меньше элементов, чем в исходном списке.
Типы данных в Python
Каждая переменная в Python — объект с определенным типом данных. Тип данных — это класс, а переменные являются экземплярами (объектами) этих классов.
В Python множество различных типов данных, мы поговорим о самых важных из них.
Числа
К этому классу относятся: целые, комплексные и числа с плавающей точкой. Определены они в Python так: int , complex и float соответственно.
С помощью функции type() можно узнать класс, к которому принадлежит переменная. А функция isinstance() проверяет принадлежность объекта к определенному классу.
Вывод:
Целые числа могут быть любой длины — ограничивает их лишь память вашего компьютера.
Число с плавающей точкой имеет точность до 15 знаков после запятой. Целая и десятичная части разделяются точками. 1 — целое число, 1.0 — число с плавающей точкой.
Комплексные числа записываются так: x + yj . Здесь x — действительная часть, а y — мнимая. Несколько примеров:
Обратите внимание, что float-переменная b усекается.
Списки
Список — это упорядоченная последовательность элементов. Это наиболее часто используемый тип данных в Python. И это не просто так: список — очень гибкий тип данных. Хотя бы потому, что элементы списка не обязательно должно быть одного типа.
Объявить список довольно просто — элементы в нем разделяются запятыми и заключены в квадратные скобки [ ] .
Чтобы получить элемент или ряд элементов из списка, воспользуйтесь срезами. Индексация начинается с 0.
Вывод:
Кортежи
Кортеж — это упорядоченная последовательность элементов, похожая на список. Единственное отличие — кортежи неизменяемы. После их объявления вы не сможете изменить значения внутри кортежа.
Кортежи гарантируют, что данные в нем не будут изменяться. Благодаря этому кортежи быстрее списков.
Объявляются кортежи с помощью круглых скобок — () , а его элементы разделяются запятыми.
Чтобы извлечь элемент из кортежа, вы можете использовать оператор среза — [] . Но не забывайте — значения кортежа менять нельзя.
Строки
Строка — последовательность символов Юникода. Для объявления строк можно использовать двойные или одинарные кавычки. Многострочные блоки текста объявляются так — »’ или «»» .
Вывод:
Со строками можно использовать срезы, но сами строки изменять нельзя.
Множества
Множество — неупорядоченный набор уникальных элементов. Множество объявляется с помощью фигурных скобок — < >. Элементы внутри множества разделяются запятыми. Элементы в списке не упорядочены.
Вывод:
Множества не упорядочены. Оператор среза с ними не работает.
Словари
Словарь — это неупорядоченный набор пар «ключ-значение».
Обычно словарь используется при работе с большим количеством данных. Словари оптимизированы под извлечение данных. Мы должны знать ключ, чтобы извлечь значение.
В Python словари объявляются с помощью фигурных скобок — < >. Каждый элемент словаря представляет собой пару в виде ключ:значение . Ключ и значение могут быть любого типа.
Для получения значения мы используем ключ — не наоборот.
Приведение типов
Для преобразования значений переменных можно использовать следующие функции: int() , float() , str() и т. д.
Приведение float к int приведет к усечению — десятичная часть отбросится.