Языки программирования

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

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

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

Все нижеприведённые примеры являются строками в понимании питона:

s = 'text' # одинарные апострофы
s = "text" # одинарные двойные кавычки
s = '''text''' # тройные апострофы
s = """text""" # тройные двойные кавычки

Строкой является любой символ (или последовательность символов), заключённый в литералы строк, в т.ч. пробелы, цифры, знаки препинания.

# Это всё строки
s = '' # пустая строка (без символов между литералами) - тоже строка
s = " " # это строка из одного пробела
s = 'мама мыла раму'
s = "1234" # это не число, это строка
s = " Привет, мир! "

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

В чём разница одинарных и тройных литералов? Стандартно для объявления строк в коде мы используем одинарные кавычки или апострофы. И чаще всего такие строки являются короткими.

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

Что значит короткая и длинная строка? Для ответа на этот вопрос вспомним PEP8: длина строки кода не должна превышать 80 символов. Пока строка текста не превышает этот предел - она считается короткой. Как только текст требует переноса - строка становится длинной.

Экранирование

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

>>> s = "text" # одинарные двойные кавычки
>>> s
'text' # в выводе - одинарные апострофы

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

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

>>> "A.Dumas - D'Artagnan et les trois mousquetaires"
"A.Dumas - D'Artagnan et les trois mousquetaires"
>>> 'Ледокол "Ленин"'
'Ледокол "Ленин"'

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

1. использовать тройные кавычки или апострофы (при чём без разницы, что вы из них выберете),

>>> """O'Reilly published D.Beazley's book "Python Cookbook" in 2013"""
'O\'Reilly published D.Beazley\'s book "Python Cookbook" in 2013'

2. использовать экранирование специальным символом обратного слэша - \.

>>> 'O\'Reilly published D.Beazley\'s "Python Cookbook" in 2013'
'O\'Reilly published D.Beazley\'s "Python Cookbook" in 2013'
>>> "O'Reilly published D.Beazley's \"Python Cookbook\" in 2013"
'O\'Reilly published D.Beazley\'s "Python Cookbook" in 2013'

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

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

Однако, прежде чем продолжить, хочу сделать ремарку для тех, кто родился в эпоху мобильных телефонов: некоторая терминология в статье, куда я вас отправил, относится к эре печатных машинок. Если вы не знаете, что такое звонок, каретка и как её переводить - "Ok, Google! Устройство печатной машинки".

Итак,

\ - если после символа \ сразу нажать Enter, то это переведёт каретку на новую строку:

>>> s = 'Это будет очень\
... , очень-очень\
... , ну прям оооооочень\
... длинная строка'
>>>
>>> s
'Это будет очень, очень-очень, ну прям оооооочень длинная строка'

\\ - экранирование символа обратного слеша (полезно при работе с файловой системой винды):

>>> s = 'D:\\мои документы\\книги\\Лутц.pdf'
>>> s
'D:\\мои документы\\книги\\Лутц.pdf'

\n - перевод каретки (новая строка):

>>> s = "Мама мыла раму\nМила раму мыла"
>>> print(s) # только функция print понимает, что делать со спецсимволами
Мама мыла раму
Мила раму мыла
>>> s # в этом случае просто выводится содержимое переменной
'Мама мыла раму\nМила раму мыла'

\t - горизонтальный отступ слева от начала строки (горизонтальная табуляция (да, есть и вертикальная)):

>>> s = '0\t1\t\t2\t\t\t3'
>>> print(s)
0 1 2 3
>>> '0 1 2 3'
'0\t1\t\t2\t\t\t3'

Achtung! Achtung! Приятные новости: в длинных строках всё это не нужно! =)

>>> s = """Эта очень длинная строка
... сама переносится, сама табулируется
... сама экранируется \."""
>>> print(s)
Эта очень длинная строка
сама переносится, сама табулируется
сама экранируется \.
>>> s
'Эта очень длинная строка\nсама переносится, сама\tтабулируется\nсама экранируется \\.'

>>> s = """Но если вдруг вам будет очень нужно прописать здесь что-то вроде '\n', то вам нужно воспользоваться экранированием, чтобы \\n не выполнялся"""
>>> print(s)
Но если вдруг вам будет очень нужно прописать здесь что-то вроде '
', то вам нужно воспользоваться экранированием, чтобы \n не выполнялся

Функция print

Тут надо бы вспомнить про функцию print. Как я уже говорил, это функция всеядная и может переварить много чего. Помимо того, что она всеядная, она ещё и достаточно хитрая. Напишите в консоли вот такую команду :

>>> help(print)

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

Help on built-in function print in module builtins:
print(...)
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.

Лаконично, просто и понятно. Вот её сигнатура:

def print(self, *args, sep=' ', end='\n', file=None):

Она говорит нам о том, что:

*args - функция всеядная, т.е. ожидает любых аргументов в любом количестве,

sep=' ' - при выводе нескольких аргументов для их отделения друг от друга по умолчанию используется пробел,

end='\n' - любой вывод по умолчанию заканчивается переводом каретки на новую строку,

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

Собственно, что это вдруг я её вспомнил? Посмотрите ещё раз внимательно. В числе её параметров присутствуют такие вещи как sep=' ' и end='\n'. Оба этих параметра принимают любые строковые символы, в том числе экранируемые. Зачем это нужно знать? Затем, чтобы иметь возможность оформлять вывод по своему желанию.

>>> a = "Мама"
>>> b = "мыла"
>>> c = "раму"
>>> print(a, b, c) # стандартный принт трёх переменных
Мама мыла раму
>>> print(a, b, c, sep='\t') # делаем разделителем табуляцию
Мама мыла раму
>>> print(a, b, c, sep='\t', end='\n\n') # добавляем лишнюю пустую строку по окончанию вывода
Мама мыла раму
>>> print(a, b, c, sep='42')
Мама42мыла42раму
>>> print(a, b, c, sep='42', end='THE END')
Мама42мыла42рамуTHE END

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

Но проще и лучше отформатировать строку заранее, чем пытаться подстроить под неё принт.

Префиксы

Кроме самих кавычек и апострофов в питоне существуют так называемые префиксы, которые определяют подвид строки. Их немного, я перечислю все, но остановлюсь только на тех, с которыми вы столкнётесь раньше всего и будете в последствии сталкиваться регулярно. Такими префиксами являются (в скобках указаны альтернативные виды написания:

u (U) - строка символов юникода (если вы не используете Python2, то можете смело о нём забыть),
r (R) - сырая строка;
b (B) - строка байтов;
f (F) - форматированная строка,
fr (rf, fR, rF, Rf, Fr, FR, RF) - сырая форматированная строка
br (rb, rB, bR, Br, Rb, BR, RB) - сырая байтовая строка.

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

Префиксы указываются до литералов без пробелов, например:

>>> s = r'\a\n'
>>> s
'\\a\\n'

Сырые строки

Сырые строки - это строки, в которых действие экранируемых символов подавляется. Проще говоря - в этих строках всё выходит на принт в первозданном виде.

Повторю пример:

>>> s = '\a\nМама' # обычная строка
>>> print(s)
# в этом месте сработал символ переноса строки "\n"
Мама

>>> s = r'\a\nМама' # сырая строка
>>> print(s)
\\a\\nМама

Сырые строки можно использовать как минимум в трёх случаях:

- в регулярных выражениях,

- для хранения файловых путей Windows, поскольку в них содержатся обратные слэши;

- для хранения сложных математических формул в разметке LATEX.

Байтовые строки

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

>>> s = 'Mama'.encode()
>>> print(s)
b'Mama'
>>> s = "Мама"
>>> s = s.encode()
>>> print(s)
b'\xd0\x9c\xd0\xb0\xd0\xbc\xd0\xb0'

Если к вам вдруг прилетела байтовая строка, то чаще всего её можно привести в человеческий вид при помощи обратного метода decode():

>>> s = b'\xd0\x9c\xd0\xb0\xd0\xbc\xd0\xb0'
>>> s = s.decode()
>>> print(s)
Мама

Форматированные строки

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

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

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

В версии Python 3.6. наконец появилась замечательная альтернатива старому методу форматирования строк str.format() - префикс f (или в обиходе - f-строки), который делает эту процедуру приятной и лёгкой до невозможности. Но вы должны это увидеть и оценить.

Итак, до версии 3.6 нужно было делать примерно так:

# представим, что общая сумма как-то посчиталась раньше и содержится в переменной total_sum
>>> total_sum = 1000
>>> final_sum_template = 'Общая стоимость покупок - {} руб.'
>>> s = final_sum_template.format(total_sum)
>>> print(s)
Общая стоимость покупок - 1000 руб.

То есть, под значение из total_sum в шаблоне заготовлено отдельное место в виде {}. Для вставки в это место требуемого значения нужно вызвать метод .format(), куда передать переменную или непосредственно само значение - и только тогда строка будет полностью сформирована. В данном примере это выглядит не так жутко. Но представьте ситуацию, когда у вас есть куча значений, которые должны лечь в одну строку. Чтобы не потеряться, в шаблоне нужно было делать именованные аргументы, чтобы потом их можно было вызывать в .format() и передавать туда значения. Например:

>>> name = "Вася"
>>> surname = "Пупкин"
>>> age = 18
>>> template = 'Это {a}. Его фамилия {b}. Вчера ему исполнилось {c} лет.'
>>> s = template.format(a=name, b=surname, c=age)
>>> print(s)
Это Вася. Его фамилия Пупкин. Вчера ему исполнилось 18 лет.

И всё это длинно, долго, муторно... А вот всё то же самое, только в f-строке:

>>> name = "Вася"
>>> surname = "Пупкин"
>>> age = 18
>>> s = f'Это {name}. Его фамилия {surname}. Вчера ему исполнилось {age} лет.'
>>> print(s)
Это Вася. Его фамилия Пупкин. Вчера ему исполнилось 18 лет.

Как минимум, у нас минус одна строка кода - это уже классно. Нет, конечно же, можно метод .format() сразу вызывать у template, но тогда мы рискуем получить очень длинную строку кода. Вдруг предложение в шаблоне уже занимает 80 символов (кстати, в "старом" шаблоне их уже 70)? Но дело даже не в этом. Я надеюсь, вы смогли оценить то, насколько процесс формирования текста упростился в этом месте. По сути это уже готовое предложение без лишней головной боли. Здесь уже нет никаких именованных заготовок, ожидающих передачу аргументов. Здесь заготовки, в которых уже стоят нужные аргументы. Кроме того, f-строки работают заметно быстрее старого метода.

Если вам мало и я вас не убедил, то почитайте вот эту статью. Если же я вас убедил, то у вас мог возникнуть вопрос: "зачем тогда вот это вот всё про устаревший метод?" Дело в том, что его пока ещё не вывели из использования. Кроме того, некоторые библиотеки, особенно те, которые написаны задолго до версии Python 3.6. и до сих пор находятся в строю, упорно не переписываются под использование f-строк. При работе с ними возникает прямая необходимость прибегать к старому методу. Поэтому для интересующихся - ссылка на старый добрый str.format()

To be continued...

-----

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

Да, и тег моё - потому что всё написано моими руками, а не тупо понакопировано с других сайтов.

P.S. Большое спасибо всем моим подписчикам за поддержку и активность! Без вас я, возможно, не решился бы продолжать.

Ссылки на предыдущие посты:

1. Предлагаю помощь в освоении Питона

2. ПЕРВОЕ ЗНАКОМСТВО С PYTHON

3. Встроенные типы данных (их назначение, методы и стандартное поведение) - Введение

4. Встроенные типы данных (их назначение, методы и стандартное поведение) - Числа

Числа

Приятно, что питоне очень много всего есть "из коробки". То есть, когда вы слышите фразу "батарейки в комплекте" - это значит, что в питоне многие вещи уже реализованы за вас, и вам не нужно ломать голову над тем, как это сделать. Например банальные арифметические операторы "+", "-", "*", "/", "//", "%", "**".

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

>>> 1 + 1
2
>>> 2 * 2
4
>>> a = 4 - 3
>>> a
1
>>> b = 10 / 2
>>> b
5.0
>>> 10 // 7 # целочисленное деление - получаем целую часть от результата выражения 10 / 7 (сколько раз семь целиком входит в десятку)
1
>>> 10 % 7 # нахождение остатка (не дробной части, а именно остатка) от деления 10 / 7. Эквивалентно выражению 10 - 10 // 7
3
>>> 10 ** 4 # возведение в степень 4
10000
>>> 10000 ** 0.5 # простое извлечение квадратного корня
100.0

Каждый оператор делает именно то, что вы от него ожидаете. Кое-где (не будем показывать пальцем) такие вещи "из коробки" были недоступны.

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

>>> a = 3
>>> a
3
>>> a = -a
>>> a
-3

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

Синтаксический сахар

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

>>> a = 2
>>> a = 2 + 2
>>> a
4

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

>>> a = 2
>>> a = a + 2
>>> a
4

Но так мы тоже делать не будем, потому что мы можем сделать вот так:

>>> a = 2
>>> a += a
>>> a
4

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

>>> a = 2
>>> a += 8
>>> a
10

Смысл оператора "+=" в том, что в правой части выражения он производит сложение нового значения с значением переменной, указанной в левой части выражения, и тут же в левой части выражения он присваивает полученный результат в старую переменную. Понятно же, да? То есть это комбинация арифметики и присваивания нового значения как с точки зрения синтаксиса, так и действий: прибавь к старому числу то же самое или другое и запиши результат в старую переменную.

Аналогично этому оператору в арсенале имеются комбинации и для оставшихся: "-=", "*=", "/=", "//=", "%=", "**=".

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

В питон встроены 5 видов чисел, первые три из которых имеются в самом питоне, два последних - в прилагаемых модулях:

- целые числа - int()
- вещественные числа - float()
- комплексные числа - complex()
- десятичные дроби - Decimal() - модуль decimal
- натуральные дроби - Fraction() - модуль fraction

Преобразование происходит всегда только в одну сторону: int --> float --> complex. Если частное двух целых чисел (int) не является целым числом, то оно будет преобразовано к вещественному типу (float), а если результат не может быть выражен типами int и float, то он будет преобразован к типу complex.

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

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

Числа с точкой

Для чисел с точкой в питоне придумано аж два отдельных типа: float и Decimal.

Стандартным поведением для питона при возникновении числа с точкой из интов является приведение его к типу float:

# получили ли вы его в результате арифметических действий
>>> a = 3
>>> type(a)
<class 'int'>
>>> a /= 2
>>> a
1.5
>>> type(a)
<class 'float'>
# или же вы его ввели вручную
>>> a = 1.5
>>> type(a)
<class 'float'>

Этот тип сохраняет число в том виде, как вы его ввели, пока вы не начали с ним производить какие-то вычисления.

>>> a
1.5
>>> a /= 2
>>> a
0.75
>>> a /= 2
>>> a
0.375

То есть, вроде бы всё идёт как надо: деление производится, знаки после точки прибавляются.

А теперь вот такой пример:

>>> 0.69 + 0,11
0.79999999999999997

Внезапно, правда? Казалось бы, должно быть 0,8, но нет. С другой стороны, погрешность настолько мала, что всё и так понятно, и можно было бы ею пренебречь. Но если ею пренебрегать достаточно долго, то произойдёт эффект накопления, что может вылиться в уже куда более серьёзную ошибку.

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

Что с этим делать? Есть несколько путей.

Путь первый: воспользоваться встроенной функцией - round(). Сигнатура функции выглядит так - round(число, количество знаков=None).

>>> a = .69 + .11 # кстати, если начать писать число с точки, то питон сам подставит перед точкой ноль.
>>> a
>>> 0.7999999999999999
>>> b = round(a)
>>> b
1
>>> c = round(a, 1)
>>> c
0.8
>>> d = round(a, 2)
>>> d
0.8

Что происходит? Передав в round только число (в нашем случае - переменную, которая на него указывает) мы получим округление до целого числа, причём оно действительно станет целым

>>> type(b)
<class 'int'>

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

Кстати, раз уж речь зашла об округлении, то стоит напомнить, что динамическая типизация не округляет число при переводе его из float в int

>>> a
0.7999999999999999
>>> type(a)
<class 'float'>
>>> int(a)
0

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

Путь второй: Decimal()

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

>>> from decimal import getcontext, Decimal # импортируем необходимое
>>> getcontext().prec = 2 # устанавливаем точность - 2 знака после точки
>>> a = Decimal(0.11) # заводим объект класса Decimal, в который передаём нужное нам число

Одно неудобство - этот тип может вычислять только сам себя. Сложить Decimal с float или int не получится - будет ошибка.

>>> b = 0.29 # это float
>>> с = a + b
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'decimal.Decimal' and 'float'

Исправляемся

>>> b = Decimal(0.69)
>>> с = a + b
>>> с
Decimal('0.80')

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

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

>>> float(c)
0.8

Либо мы просто все числа заводим через Decimal и используем методы, которые он нам предоставляет. Зато можно на ходу поменять точность

>>> getcontext().prec = 40
>>> a + b
>>> Decimal('0.7999999999999999472644063303050643298775')

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

-----

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

Да, и тег моё - потому что всё написано моими руками, а не тупо понакопировано с других сайтов.

P.S. Большое спасибо всем моим подписчикам за поддержку и активность! Без вас я, возможно, не решился бы продолжать.

Ссылки на предыдущие посты:

1. Предлагаю помощь в освоении Питона

2. ПЕРВОЕ ЗНАКОМСТВО С PYTHON

3. Встроенные типы данных (их назначение, методы и стандартное поведение) - введение

Изменяемые и неизменяемые типы данных

В пайтоне, как и в других высокоуровневых языках, существуют изменяемые (mutable) и неизменяемые (immutable) типы данных.

К стандартным встроенным неизменяемым типам относятся:

None
bool - True/False
числа - int(), float(), complex()
строки - str()
кортежи - tuple()
неизменяемые ("замороженные") множества - frozenset()
байты - bytes()

К изменяемым:

списки - list()
множества - set()
словари - dict()
списки байтов - bytearray()

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

Вспомним пример из вводной статьи про пятёрку:

>>> a = 5
>>> id(a)
1609562080

Заменяя пятёрку на любое другое число, мы теряем эту пятёрку, и переменная "а" начинает ссылаться на новое число, которое будет храниться в новой ячейке памяти:

>>> a = 6
>>> id(a)
1411840000

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

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

>>> lst = [1, 2, 3] # создаём список из трёх чисел
>>> id(lst) # запрашиваем номер ячейки памяти, где он сохранён
49718408 # получаем ответ на запрос
>>> lst # просим вывести переменную на печать

Прим.: в коде вывод на печать - только через print(), в консоли можно и так, и так: и через "print()", и через "переменная+Enter"

[1, 2, 3] # вывод на экран содержимого переменной "lst"
>>> lst.clear() # очищаем список полностью, делая его пустым
>>> lst
[] # список опустел
>>> id(lst)
49718408 # адрес ячейки не изменился - значит объект всё тот же

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

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

>>> a = 5
>>> b = a
>>> a
5
>>> b
5
>>> id(a)
1407776752
>>> id(b)
1407776752
>>> b + 1
>>> a
5
>>> b
6
>>> id(a)
1407776752
>>> id(b)
1407776768

Из этого примера видно, что сначала обе переменные ссылаются на одну и ту же пятёрку. Затем мы к "b" прибавили единицу, и, о чудо, в ней оказалась шестёрка, а шестёрка - это новый объект, у которого своё место в памяти. При этом "a" никуда не делась, не изменилась и осталась ссылаться на пятёрку.

Подобный фокус с изменяемыми типами не пройдёт.

>>> lst = [1, 2, 3]
>>> new_lst = lst
>>> id(lst)
49718216
>>> id(new_lst)
49718216
>>> lst
[1, 2, 3]
>>> new_lst
[1, 2, 3]
>>> new_lst.clear()
>>> new_lst
[]
>>> lst
[]
>>> id(lst)
49718216
>>> id(new_lst)
49718216

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

Для копирования изменяемых типов существует встроенный модуль "copy". Цитата из официальной документации модуля:

DESCRIPTION
Interface summary:
import copy
x = copy.copy(y) # make a shallow copy of y (поверхностное копирование)
x = copy.deepcopy(y) # make a deep copy of y (глубокое копирование вложенных структур)

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

И ещё разок: назначение нескольких переменных для одного объекта - это НЕ КОПИРОВАНИЕ, т.к. вследствие этих действий вы не создаёте новый объект. Копирование неизменяемых объектов в принципе невозможно, так как неизменяемый объект уникален, и даже применение модуля copy лишь создаст новую ссылку на этот объект.

>>> a = 5
>>> b = copy.copy(a)
>>> a
5
>>> b
5
>>> id(a)
1403844592
>>> id(b)
1403844592
Копировать в чистом виде можно только изменяемые объекты.
>>> lst = [1,2,3]
>>> new_lst = copy.copy(lst)
>>> lst
[1, 2, 3]
>>> new_lst
[1, 2, 3]
>>> id(lst)
49634696
>>> id(new_lst)
49794312

Коллекции, последовательности

Коллекциями стандартно называются объекты, содержащие упорядоченный или неупорядоченный набор элементов разных типов, в том числе типов, одинаковых с типом самой коллекции (например: списки списков, кортежи кортежей и т.п.).

ВИДЫ КОЛЛЕКЦИЙ

NB!: строки также являются последовательностями

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

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

Срез - выборка элементов из последовательности в формате [start:stop:step], т.е.:

- стартовый индекс,

- конечный индекс (невключительно),

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

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

>>> s = "Hello, world!" # строки - разновидность последовательностей
>>> s[0] # первый элемент строки
'H'
>>> s[-1] # последний элемент строки
'!'
>>> s[-2] # предпоследний элемент строки
'd'
>>> s[2:-2] # срез строки c ТРЕТЬЕГО (считаем от нуля) по предпоследний (НЕВКЛЮЧИТЕЛЬНО) элементы
'llo, worl'
>>> s[1:-1:3] # срез строки cо ВТОРОГО (считаем от нуля) по последний (НЕВКЛЮЧИТЕЛЬНО) элементы с шагом "каждый третий (в человеческом понимании) элемент от старта, включая стартовый"
'eowl'

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

>>> s[2:] # Срез от третьего элемента до конца последовательности
'llo, world!'
>>> s[:2] # Срез начала последовательности до третьего элемента невключительно
'He'
>>> s[::2] # Срез последовательности с шагом "каждый второй элемент, включая первый"
'Hlo ol!'
Шаг может быть также отрицательным. Тогда последовательность обходится с конца (в обратном порядке).
>>> s[::-1] # Срез с шагом "каждый элемент в обратном порядке"
'!dlrow ,olleH'
>>> s[::-2] # Срез с шагом "каждый второй элемент в обратном порядке, начиная с последнего"
'!lo olH'

Все остальные виды коллекций - неупорядоченные (исключение - OrderedDict из модуля collections, но в данном случае он нас не интересует) , то есть вызвать элемент по его индексу из множества или словаря невозможно, равно как и сделать их срез.

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

-----

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

Да, и тег моё - потому что всё написано моими руками, а не тупо понакопировано с других сайтов.

P.S. Большое спасибо всем моим подписчикам за поддержку и активность! Без вас я, возможно, не решился бы продолжать.

Ссылки на предыдущие посты:

1. Предлагаю помощь в освоении Питона

2. ПЕРВОЕ ЗНАКОМСТВО С PYTHON

Общие понятия

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

Эту фразу видели все, кто хоть раз в жизни открывал статью про Python на Википедии. Вроде бы всё просто и ясно, но как-то не очень. Уже здесь встречаются непонятные термины: кроссплатформенный, высокоуровневый… Дать ёмкое и понятное определение чему бы то ни было – это великое искусство. Поэтому, я думаю, стоит пояснить всё вышесказанное простыми словами. А простыми словами это выглядит примерно так: Пайтон – это язык программирования, который можно использовать на любой известной стандартной операционной системе (Windows, MacOs, Linux) и при помощи которого можно написать практически любую программу (от «Привет, мир!» до новой операционной системы или нового языка программирования). Звучит заманчиво, не так ли?

Пайтон был придуман в 1991 году голландцем Гвидо ван Россумом, также известным как «великодушный пожизненный диктатор». Именно он по сей день принимает окончательные решения о том, как именно будет развиваться язык. Кстати, последняя версия питона (3.9.0) вышла буквально на днях – 05.10.2020. Её главная особенность для новичков, на мой взгляд, в том, что для её установки требуется минимум Windows 10 (на семёрку она не инсталлируется). Всё, чему будут посвящены мои статьи, гарантированно будет актуальным для версий 3.6.0-3.9.0. Версии питона 2.Х здесь рассматриваться не будут, т.к. для разработки новых приложений они уже не используется, а те, кто всё ещё стоически поддерживает приложения, написанные на них, вряд ли будут всё это читать.

Объектно-ссылочная модель

В своих интервью Гвидо подчёркивал, что никогда не видел Python в качестве языка сугубо функционального программирования. С самого начала питон позиционировался как язык объектно-ориентированного программирования (ООП), однако, он на нём можно писать в абсолютно любой парадигме - структурное, обобщенное, объектно-ориентированное, функциональное и аспектно-ориентированное программирование. Не буду заострять внимание на том, что означает каждый из них. Если интересно - это легко гуглится. Что же касается ООП, то пайтон спроектирован таким образом, что абсолютно всё, что в нём есть, т.е. все типы данных, функции, методы, классы, переменные – всё это является объектами, то есть некоторыми сущностями, обладающими определённым состоянием и поведением, имеющими определённые свойства (атрибуты) и операции или действия над ними (методы). Что это означает на практике, мы увидим уже достаточно скоро, а пока что просто примите это и уверуйте, что это именно так.

Переменных (в привычном понимании – «контейнеров») в питоне не существует. Когда в коде встречается нечто вроде «а = 5», серьёзные бородатые программисты в свитерах вам скажут, что «а» - это переменная, в которую записано значение «целое число пять». В случае с питоном это утверждение правда и неправда одновременно. В питоне «целое число пять» – это самостоятельный неизменяемый объект, который лежит где-то в оперативной памяти вашего компьютера. Например, выполним в консоли интерпретатора следующую команду

>>> id(5)
1609562080

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

Следом выполним ещё пару команд:

>>> a = 5
>>> id(a)
1609562080

Оказывается, у переменной «а» тот же адрес, что и у самой пятёрки. Но ведь если в питоне всё является объектом, то переменная – это контейнер, а значит тоже объект, то у неё должен быть свой адрес? Ответ – нет. В питоне нет переменных-контейнеров. Вместо этого в питоне есть ссылки на объекты. В данном случае «а» - это ссылка на число 5. Как это ещё проверить? Очень просто. Выполним ещё одну команду

>>> b = 5
>>> id(b)
1609562080

То же самое?! Да, именно так. Переменная «b» ссылается всё на ту же самую пятёрку. Последняя проверка этой теории:

>>> a is b
True

Переменная «а» - это то же самое, что и переменная «b», и любая другая «переменная», которая будет ссылаться на пятёрку, какое бы имя вы ей не придумали.

Возникает вопрос: а что же тогда такое знак «=» в данном случае? В питоне знак «=» не знак равенства, а оператор присваивания. Равенство в питоне выражается через оператор «==», который используется исключительно в булевой логике, т.е. для сравнения значений и/или содержимого разных объектов.

Итак, вывод: в питоне переменных нет, знак «=» не приравнивает значение к переменной и не записывает значение в переменную, а присваивает какому-либо объекту именную ссылку для удобства обращения.

Динамическая типизация

Динамическая или как принято в питонической среде - «утиная типизация». Это очень простая концепция: «Если что-то выглядит как утка, плавает как утка и крякает как утка, то это наверняка и есть утка».

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

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

>>> a = 5
>>> type(a)
<class 'int'>
>>> a = str(a)
>>> type(a)
<class 'str'>
>>> a
'5'

Вот и всё, теперь переменная «а» ссылается уже не на целочисленный объект 5, а на строковый объект 5. Для наглядности я сразу запросил тип каждого из объектов, и оснований не верить результатам лично у меня нет: вначале пятёрка – это число, в конце – строка. Об этом говорит не только type(a), но и само значение, которое раньше было голой пятёркой, а теперь обрамлено кавычками.

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

Стиль кодирования. PEP8

У каждого языка программирования, как и любого другого языка, есть свои законы, которым он подчинён. Если русском языке мы пишем названия месяцев со строчной буквы (9 мая, 8 марта), то в английском, например, месяцы всегда пишутся с прописной (January, 4th of July). Питон также имеет свою семантику, грамматику и свой синтаксис. Основным сводом законов, определяющих требования к красивому и качественному стилю кодирования определены в документе, который называется Python Enhancement Protocol 8 или PEP8. Основные правила на самом деле достаточно просты, но почему-то на каждом новом курсе я встречаю людей, упорно их игнорирующих.

Давайте начнём с того, что Python – язык международный. Это вам не 1С, на котором пишут в буквальном смысле по-русски. В питоне всё по-английски. Всё и всегда. Мне попадались 2 уникума, которые упорно именовали переменные по-русски. Объясняли они это тем, что «так понятнее». Нет, если вы не знаете английского, то вам, возможно, будет понятнее. Но нужно учитывать, что IT – это англоязычная среда, все программы, и 90% документации написаны именно на английском, и, в конце концов, ваш код могут читать (а большинство времени будет потрачено именно на его чтение, причём не только вами) люди, не знающие русского. Ну или давайте наоборот: вам прислали на проверку кусок кода, где половина на хинди или суахили. Как вам такое? Возьмите себя в руки и если вы не знаете или плохо знаете английский – начните его учить с нуля. Не брезгуйте онлайн-переводчиками и словарями для выбора имён переменных и функций – это не стыдно.

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

>>> a = 5
>>> b = "mama"
>>> for i in b:
... print(i * a)
...
mmmmm
aaaaa
mmmmm
aaaaa

Казалось бы, всё работает – что ещё нужно? Да, работает. Даже если бы переменные были названы по-русски или по-китайски, то же бы работало, так как питону глубоко всё равно, какой алфавит вы используете для обозначения ссылок - он всё это перерабатывает в байтовые представления символов юникода. Кошмар же заключается в том, что не соблюдено главное правило питониста: код должен быть читаемым. Читаемым человеком, его глазами. Возможно, сейчас это будет сложно, но попробуйте представить, что между объявлением переменных и циклом for не ноль строк, как сейчас, а 100-150-200. Да, это утрированный пример, но всё-таки. Никто через 100, да даже через 50 строк не вспомнит, что такое переменные «a» и «b». Ну какие-то там переменные, но что в них лежит, на что они ссылаются? Может это число и строка? А может это строка и число? А может это и не строка и не число? Надо лезть выше, искать их, разбираться. Опять всё сводится к бесполезной трате времени.

Не проще ли было сразу назвать эти переменные по-человечески (в прямом смысле)? Давайте попробуем:

>>> number = 5
>>> string = "mama"
>>> for i in string:
... print(i * number)
...
mmmmm
aaaaa
mmmmm
aaaaa

Выхлоп не изменился, но мозгу становится понятнее, глазу приятнее. Осталось разобраться с «i».

В строке «for i in string» «i» является ничем иным как временной переменной. Её тоже нужно уметь красиво и понятно назвать. Как показывает моя собственная практика, иногда хорошее, грамотное название переменной снимает у студентов возникшие вопросы по дальнейшим действиям. Они внезапно начинают понимать, что делали не так и что нужно на самом деле делать и куда двигаться. Так давайте уже её переделаем и пойдём дальше:

>>> number = 5
>>> string = "mama"
>>> for letter in string:
... print(letter * number)
...
mmmmm
aaaaa
mmmmm
aaaaa

Именно это и описано в PEP8 – как писать качественный код, отвечающий требованиям и стилю Python, или как принято говорить – pythonic style или pythonic way. Многие из нас, кто ещё в школе пытался учиться программированию, помнят такой язык, как Basic или QBasic. Потом он перерос в VBA и до сих пор (к сожалению…) используется для написания макросов в офисных программах Microsoft. И в связи с этим у многих из нас при изучении питона всплывает Basic style – стиль кодирования на Basic. Pythonic style ушёл намного дальше. Читаемость кода за счёт простоты синтаксиса повысилась в разы. Вот для наглядности пример.

Задача: получите из входного потока число и напечатайте сумму его цифр.

Как бы эту задачу решило большинство в «Basic style»:

>>> number = input()
>>> summa = 0
>>> for dig in number:
… if dig in '0123456789':
…  summa = summa + int(dig)
>>> print(summa)

Как это решается в «Pythonic style»:

>>> print(sum(int(x) for x in input() if x.isdigit()))

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

Давайте тезисно определим основные правила синтаксиса:

- используя питон, мы пишем на английском языке;

- все названия переменных, функций, классов должны как можно полнее отражать их суть и содержание;

- названия переменных и функций принято писать в нижнем регистре, разделяя слова подчёркиванием (snake_case):

# ПРАВИЛЬНО
my_number = 42
def my_function():

#НЕ правильно
MyNumber = 42
Mynumber = 42
MYNUMBER = 42
mynumber = 42
МоЙнОмЕр = 42
def MyFunction():
def Myfunction():
def MYFUNCTION():
def myfunction():

- названия классов принято писать в CamelCase – слова пишутся с заглавной буквы без разделителей между словами:

# ПРАВИЛЬНО
class MySuperPuperClass:

#НЕ правильно
все остальные варианты

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

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

- вложенные инструкции объединяются в блоки по величине отступов. 1 отступ = 4 пробела;

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

if a == 1:
print('mama' * 3)  # 4 пробела после двоеточия

- в случае, если длина инструкции превышает 80 знаков, допустимо записывать одну инструкцию в нескольких строках. Достаточно ее заключить в пару круглых, квадратных или фигурных скобок:

if (a == 1 and b == 2 and
c == 3 and d == 4):  # продолжение инструкции выравнивается по открывающей скобке
print('mama' * 3)  # 4 пробела после двоеточия

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

>>> if x > y: print(x)

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

>>> a = 1; b = 2; print(a, b)

Это основные вещи, которые нужно выучить. Благо, что мы живём в 21 веке и рабочие среды уже давно умеют анализировать наш код на соответствие стилю, а также полно разнообразных сторонних линтеров. Поэтому, если вы переживаете, что вы не осилите этот момент – ваша IDE вам подскажет, где что поправить, и в большинстве случаев – сама же и поправит. Если она этого самостоятельно делать не умеет, то можно воспользоваться сторонними линтерами.

Что будет, если на всё это забить и писать как бог на душу положит? Да ничего. Просто вас проклянут до десятого колена те, кто будет это читать, а в остальном ничего.

Дзен питона

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

>>> import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Перевод на русский конечно же существует:

Дзен Пайтон (составлен Тимом Питерсом)
Красивое лучше, чем уродливое.
Явное лучше, чем неявное.
Простое лучше, чем сложное.
Сложное лучше, чем запутанное.
Плоское лучше, чем вложенное.
Разреженное лучше, чем плотное.
Читаемость имеет значение.
Особые случаи не настолько особые, чтобы нарушать правила.
При этом практичность важнее безупречности.
Ошибки никогда не должны замалчиваться.
Если не замалчиваются явно.
Встретив двусмысленность, отбрось искушение угадать.
Должен существовать один — и, желательно, только один — очевидный способ сделать это.
Хотя он поначалу может быть и не очевиден, если вы не голландец (это такая шутливая отсылка к Гвидо).
Сейчас лучше, чем никогда.
Хотя никогда зачастую лучше, чем прямо сейчас.
Если реализацию сложно объяснить — идея плоха.
Если реализацию легко объяснить — идея, возможно, хороша.
Пространства имён — отличная вещь! Давайте будем делать их больше!

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

«Hello, world!»

Пришло время написать первую программу. Хотя на самом деле это не так. Свою первую программу все те, кто скачал и поставил себе пайтон, уже написали. С точки зрения программирования рабочей программой называется та программа, которая запускается и не выдаёт ошибок. Так что с этой точки зрения пустой код – это вполне рабочая программа. Вы можете в этом сами убедиться, создав пустой файлик с расширением .py и запустив его через вашу IDE. Физически ваша «программа» ничего не выдаст, но интерпретатор вам скажет «Process finished with exit code 0», что означает, что код был запущен и завершен без ошибок, а значит он вполне рабочий.

Под первой программой стандартно понимается программа, выводящая на экран сообщение «Hello, world!» - то есть нам нужно просто вывести текст на экран. Для вывода на экран существует встроенная функция «print». Для вызова функции нам необходимо добавить к её названию круглые скобки: print().

Можно написать в консоли print(), нажать Enter – программа отработает без ошибок, но ничего напечатано не будет. И это нормально, ведь мы не сказали функции, что именно ей нужно напечатать. Пока что мы просто заставили её сработать вхолостую, что она и сделала.

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

Текст в питоне – это тип данных «строка» (подробнее о них мы поговорим в следующий раз, и поверьте, там есть о чём). Строки должны быть заключены в кавычки.

Hello, world! – это не строка.

"Hello, world!" – а вот это уже строка.

Значит именно так мы и должны передать её в функцию print.

Итак,

>>> print("Hello, world!")
Hello, world!

Отлично, мы сделали это! Но, можно ещё интереснее. Например, можно записать строку в переменную, передать в функцию эту переменную и распечатается та же строка:

>>> hello = "Hello, world!"
>>> print(hello)
Hello, world!

Мне надоело здороваться со всем миром, я хочу разнообразия. Для этого я хочу сам говорить программе, с кем поздороваться. Для этого я вызову функцию ввода с клавиатуры «input».

>>> hello = "Hello, "
>>> name = input() # с клавиатуры вводим любое слово, например, Петя
>>> print(hello, name, "!")
Hello,  Петя !
>>> print("Hello, " + name + "!")
Hello, Петя!

На сегодня это всё, спасибо за внимание!

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

Да, и тег моё - потому что всё написано моими руками, а не тупо понакопировано с других сайтов.

P.S. Большое спасибо всем моим подписчикам за поддержку и активность! Без вас я, возможно, не решился бы продолжать.

Ссылки на предыдущие посты:

1. Предлагаю помощь в освоении Питона

Всем привет!

На фоне пандемии у населения резко возрос интерес к изучению каких-либо языков программирования с целью «уйти в ай-ти». Стать программистом – желание похвальное, но стать хорошим и востребованным программистом на деле оказывается не так просто, как вам обещает реклама. За 6-12 месяцев от нуля до сениор-разработчика вырасти невозможно. За это время в лучшем случае можно более-менее уверенно освоить один язык программирования, менее уверенно пару фреймворков к нему и пописывать какие-то мелкие программки для решения собственных нужд. Нет, есть конечно же уникумы, но их единицы на тысячи.

Я являюсь помощником менторов на одном из известных порталов онлайн-обучения. На каком именно – неважно, ибо, во-первых, я не хочу, чтобы меня обвиняли в рекламе, во-вторых, они все по большому счёту одинаковые, разница лишь в шильдике и ценнике за этот шильдик. Так вот, глядя на то, как новичков, которые ещё вчера были бухгалтерами, строителями, водителями (выберите нужное или вставьте своё), без оглядки гонят по готовой программе, мне становится немного жутко. Жутко от того, что наивных людей как минимум ввели в заблуждение относительно простоты получения квалификации, т.е. набора знаний, дающих право на работу в сфере IT. Им обещают, что через полгода они смогут творить чудеса своими руками не выходя из дома. Да, местами, действительно, это возможно, но лишь местами. При этом, программы обучения могут быть сырыми и необкатанными, лекции - сбивчивыми, лекторы – пустословными. Я не хочу сказать, что так везде, но местами так случается. Форма подачи материала играет очень важную роль в любом процессе обучения, особенно, если это обучение с нуля.

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

- материала много, и всё за один вебинар рассказать не удаётся (ограниченная подача информации),

- материал подаётся бессистемно и сбивчиво (неопытность лектора как преподавателя),

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

- а также многое другое.

Сразу хочется предупредить восклицание «да это просто студенты тупые». Отнюдь. Когда человек сам платит деньги за обучение – он обычно знает, чего хочет и зачем ему это нужно. То есть он готов и хочет учиться, но не может воспринять материал, вследствие чего в его голове возникает каша из бессистемных знаний. И всё это уже на базовом уровне, то есть именно там, где всё нужно не просто забить к себе в голову, а разложить по полкам и знать где и что лежит, чтобы в нужный момент это взять, даже если вас подняли посреди ночи. Дело не в зубрёжке. Дело в понимании. Если нет понимания процесса, то нет и возможности этот процесс реализовать.

Глядя на мучения новичков, я собрался с мыслями и решил написать серию статей, посвящённых основам программирования на одном из самых ныне популярных языке программирования Python. Python стал резко занимать лидирующие позиции в рейтингах популярности благодаря именно вам, дорогие мои новички. Именно вы, желающие «легко запрыгнуть в IT», выбираете Python в качестве своего первого языка программирования, чем задираете его рейтинги. И это прекрасно, потому что Python прекрасен сам по себе. Он лаконичен, понятен, относительно прост, гибок - тем самым удобен для изучения и для обучения. Мои статьи будут касаться самых базовых вещей. Я постараюсь как можно подробнее и понятнее разобрать все основные моменты, с которых начинается “pythonic way”, а также типичные ошибки, с которыми сталкиваются новички.

Не ждите, что я вам скажу что-то принципиально новое. Всё, что я буду излагать, можно было бы легко найти в другом месте. Есть куча сайтов с бесплатным контентом и даже бесплатными курсами. Всё это легко гуглится. Я сам их использовал в своё время, да и сейчас иногда проще что-то быстро нагуглить, чем читать специальную литературу или официальную документацию. В то же время, могу сказать, что лично мне некоторых вещей очень не хватало на старте изучения Python. Прежде всего, не хватало объяснения под другим углом, с другими примерами, иногда очень хотелось повышенной многословности вместо сухих фраз или просто брошенных кусков кода («читай – там всё написано»).

Я рассчитываю, что эти статьи вам помогут начать писать свои собственные программы «для дома, для семьи». Мы не будем лезть в такие дебри, как например, асинхронность. Мы также не будем рассматривать такие библиотеки как NumPy, matplotlib. Только необходимый минимум, только база, никакого хардкора. Но мы будем это делать обстоятельно и поступательно, связывая одно с другим и обрастая нужной информацией углубляться дальше. В каждой теме будут присутствовать примеры в виде рабочих и понятных кусков кода (никаких бессмысленных foo-bar).

В первом приближении план таков:

1. Первое знакомство с Python:
1.1. Общие понятия.
1.2. Объектно-ссылочная модель.
1.3. Стиль кодирования. PEP8
1.4. Дзен питона
1.5. Hello world
2. Встроенные типы данных (их назначение, методы и стандартное поведение):
2.1. Изменяемые и неизменяемые типы данных. Коллекции, последовательности.
2.2. Числа
2.2.1. Целые
2.2.2. Десятичные
2.3. Строки
2.3.1. Обычные
2.3.2. Сырые
2.3.3. Форматирование строк
2.4. Списки
2.5. Кортежи
2.6. Множества
2.7. Словари
2.8. CSV, JSON, XML, YAML (обзорно без углубления)
3. Булева логика
4. Ветвления:
4.1. Общая теория ветвлений
4.2. Проверки объектов
5. Циклы WHILE и FOR
6. Функции:
6.1. Обычные функции и их аргументы
6.2. Анонимные lambda функции
6.3. Рекурсия и стек вызовов
6.4. Встроенные функции
6.5. RETURN – что это и зачем он нужен, если есть PRINT
7. Генераторы (первое приближение)
7.1. Инструкция YIELD
7.2. Генераторные выражения
7.3. Генераторы списков, множеств, словарей (они же – списковые, множественные, словарные включения, они же - list, set, dict comprehensions)
8. Работа с файлами
9. Многофайловые программы:
9.1. Модули
9.2. Пакеты
9.3. Инструкция if __name__ = = __main__
10. Объектно-ориентированное программирование (ООП)
10.1. … (детальный план в разработке)
11. Тестирование кода
11.1. … (детальный план в разработке, одно точно – это будет про PyTest)
12. … (можете подкинуть идей, если хотите)

План неокончательный ни по составу, ни по компоновке, но общий скелет и путь именно такой.

Надеюсь, что всё это поможет всем, кто ищет помощи, но не может её по каким-то причинам найти.

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

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