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

"Строка"
'Строка'

Интерпретатор выводит строки в одинарных кавычках, но обрабатываются любые.

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

"Вот строка, а вот текст в 'кавычках'"

'Тоже самое, но "наоборот"'

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

"""Строка"""

'''Строка'''

Но у них есть особенность - это работа с многострочным текстом, к примеру четверостишье Бунина:

text = """В сухом лесу стреляет длинный кнут,
В кустарнике трещат коровы,
И синие подснежники цветут,
И под ногами лист шуршит дубовый.
"""

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

'В сухом лесу стреляет длинный кнут,\nВ кустарнике трещат коровы,\nИ синие подснежники цветут,\nИ под ногами лист шуршит дубовый.\n'

Заметили \n? Это символ переноса строки, о нем мы поговорим позже.

А если вывести через print():

print("В сухом", 'лесу', """стреляет""", '''длинный кнут''')

Получим: В сухом лесу стреляет длинный кнут. Функция print() добавляет пробелы между аргументами.

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

''
""
''' '''
""" """

Функция str()

У Python есть отдельная функция которая умеет создавать строку из другого типа данных - str():

str(98.6)
# '98.6'

str(1.0e4)
# '10000.0'

str(True)
# 'True'

Escape последовательность

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

text = 'Один, \nДва, \nТри.'

print(text)
# Один,
# Два,
# Три.

Кроме того в Python есть последовательность табуляции \t которая помогает выравнивать текст:

print('\tабв')
    абв

print('а\tбв')
а    бв

print('аб\tв')
аб    в

print('абв\t')
абв

В последнем примере табуляция есть, но увидеть мы ее не сможем

Рассмотрим еще один пример последовательности, но уже для работы с кавычками \' и \":

text = "\" Раз! \" Два! \" Три! \""
'" Раз! " Два! " Три! "'

print(text)
" Раз! " Два! " Три! "

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

text = "Вот \\ - слеш"
print(text)
# Вот \ - слеш

Объединение строк символом +

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

'Первый ' + 'Второй'
# 'Первый Второй'

'Первый' + 'Второй'
# 'ПервыйВторой'

'Первый' + ' ' + 'Второй'
# 'Первый Второй'

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

"Первый " "Второй"
# 'Первый Второй'

Размножение строк

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

one = "Один " * 3 + '\n'
two = "Два " * 4 + '\n'
three = "Три."

print(one + one + two, three)

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

Извлечение символов при помощи []

Переходим к более интересной работе со строками, для того что бы получить один символ из нашей строки необходимо указать его индекс в квадратных скобках [], напомню что в языке Python есть смещение и мы начинаем с [0]:

string = "абвгд"
string[0]
# а

string[-1]
# д

string[2]
# в

Стоит учесть следующее - если мы укажем индекс больше длины строки, то получим исключение:

Строки являются неизменными по этому если мы попробуем по индексу задать новое значение то получим исключение:

name = 'Kirill'
name[0] = 'R'

И тут на помощь приходят новые функции replace() и slice(), про них поговорим позже. А пока взглянем на код:

name = 'Kirill'
name.replace('K', 'R')
# 'Ririll'

'R' + name[1:]
# Ririll

Помните про неизменность? Интерпретатор не меняет значение у переменной, а лишь выводит результат замены.

Подстроки и разделение

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

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

От теории к практике - подробнее:

• [:] возвращает всю последовательность целиком (фактически срез от начала до конца)
• [начало:] берет элементы, начиная с позиции начало, и до самого конца
• [:конец] берет элементы от начала и до позиции конец - 1 (правая граница не включается)
• [начало:конец] извлекает фрагмент от позиции начало до позиции конец - 1 (правая граница также не включается)
• [начало:конец:шаг] извлекает элементы от начало до конец - 1, выбирая каждый шаг элемент (то есть берутся позиции начало, начало + шаг, начало + 2*шаг и т. д., пока не достигнем конец)

Как в предыдущих материалах я описывал смещение происходит слева на право и начинается с 0 и далее, а справа на лево -1, -2 и т.д. Если мы не укажем оператору [:] начало, по умолчанию будет использовать 0, а если не указать конец то будет использовать конец строки.

Хватит теории, сейчас поймем все на практике, напишем простую строку:

text = "привет"

print(text[:])
# привет

Если мы используем оператор [:] без аргументов, то это аналогично что начало у нас 0 и конец до конца строки.
А вот таким образом мы можем получить всем символы, начиная с 2:

text = "привет"
print(text[2:])
ивет

А теперь попробуем указать конец:

text = "привет"
print(text[2:5])
# иве

Помните про массивы списки? Представьте что наше слово привет это список - ["п","р","и","в","е","т"]
У каждого символа/буквы есть свой индекс - п=0, р=1 Так Вам будем проще ориентироваться.

Теперь попробуем задать начало с отрицанием:

text = "привет"
print(text[-2:])
# ет

Поняли что произошло? Произошел реверс, то есть наше начало пошло с конца, попробуй поэтапно начиная с -1 увеличить до -6, и в конечно итоге мы выведем наше привет.

А теперь попробуем начало задать положительным числом, а конец отрицательным:

text = "привет"
print(text[1:-1])
# риве

Мы начали с индекса 1 и закончили индексом -1 тем самым отсекли первый и последний символ.

А теперь попробуем сделать числа все отрицательными:

text = "привет"
print(text-2:-1])
# е

Напоминаю про списки и индексы, -2=е а -1=т Мы начали наше разделение с символа е и закончили на символе т - он не включается в вывод, так как является концом.

Теперь попробуем увеличить шаг:

text = "привет"
print(text::2])
# пие

А теперь мы начали с индекса 0 он же символ п и продолжаем до конца строки, но в этот раз мы перепрыгиваем через один символ так как указали последним аргументом 2.

Мы также можем объединить все:

text = "привет"
print(text[1:6:2])
# рвт

Тут мы начали с 1=р, закончили 6=т и сделал шаг между ними в 2.

Взглянем еще на такой пример:

text = "привет"
print(text[1::2])
# рвт

Получим тоже самое что и в предыдущем, но в чем же разница? А разница в том что мы выводим каждый 2 символ начиная с 1=р.

Мы также можем начинать с каждого второго символа, начиная с 0 до 6(конца):

text = "привет"
print(text[:6:2])
# пие

И на этом еще не все, мы также можем поставить начало и шаг отрицательным, взглянем:

text = "привет"
print(text[-1::-1])
# тевирп

Таким образом Python позволяет передвигаться в обратную сторону, но этот же результат мы можем получить без назначения начало -1, сделав просто шаг -1:

text = "привет"
print(text[::-1])
# тевирп

Сам по себе оператор разделения [:] лоялен к различным смещениями в отличии от поиска по индексу (списки) [].
Если мы укажем смещение меньше чем начало строки то оно обработается как 0, а если укажем смещение больше чем конец строки то обработается как -1. Взглянем на пример:

text = "привет"
print(text[-7:])
# привет

print(text[:50])
# привет

Измерение длины строк - функция len()

Материал будет добавлен по мере написания

И так наконец-то мы боле менее подготовлены к следующему этапу - структурированию кода при помощи операторов - if, elif, else. И сразу приступим писать код, в качестве примера возьмем переменную с булевым значением. Ах да, также рекомендую начинать работать не в интерпретаторе, а через IDE и привыкать писать код в файлах. Создайте файл main.py и давайте напишем следующий код:

title = True

if title:
    print("Title is True")
else:
    print("Title is False")

После того как напишите коде, сохраните файле и вызовите его через консоль - python3 main.py
Если все корректно, то увидите в консоли строку - Title is True

Теперь подробнее про операторы if и else - эти операторы проверяют является ли значение нашего выражения равным True и выводит сообщение - Title is True. А если значение ложь (False) то выведет - Title is False. Надеюсь логика понятная тут ничего сложного нету.

Давайте напишем пример чуть-чуть посложнее, мы можем использовать проверку столько раз сколько захотим этого:

title = True
titleOne = True

if title:
    if titleOne:
        print("TitleOne is True")
    else:
        print("TitleOne is False")
else:
    if titleOne:
        print("TitleOne is True")
    else:
        print("TitleOne is False")

Обратите внимание на отступы - в Python они не косметика, а синтаксис. Интерпретатор по количеству пробелов понимает, где заканчивается блок if и начинается вложенный.

PEP 8 (стандарт стиля) требует ровно 4 пробела на уровень - без табов. В примере:

• Первый if title: проверяет title (True), входит в блок.
• Python видит следующие строки с +4 пробела - они “прикреплены” к этому if.
• Вложенный if titleOne: имеет +8 пробелов от начала - его пара else на том же уровне.

Без отступов мы получим ошибку - IndentationError. Это делает код читаемым и строгим.

Идем дальше и разберем пример еще сложнее, и так нам нужно проверить больше двух вариантов. Мы будем использовать операторы в определенной последовательности - if для первого варианта, elif (он же else if - иначе если) для промежуточных вариантов и else для последнего:

color = "blue"

if color == "red":
    print("The color is red.")
elif color == "green":
    print("The color is green.")
elif color == "purple":
    print("The color is purple.")
else:
    print("The color is not red, green, or purple.")

Важный момент: ни один if/elif не сработал (color ≠ red/green/purple), поэтому выполняется финальный else - выводит “The color is not…”. Штатная логика: else ловит все неподходящие случаи. Без else код просто завершится молча.

Обратим внимание на оператор == который проверяет равенство, по мимо него есть и другие:

• равенство (==)
• неравенство (!=)
• меньше (<)
• меньше или равно (<=)
• больше (>)
• больше или равно (>=)

Эти операторы возвращают булевы значение - True или False.
Давайте посмотрим на то как они работают:

x = 10

x == 10
# True

x == 5
# False

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

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

Взглянем на пример:

x = 7
5 < x and x < 10
# True

В данном примере мы установили значение переменной x равным 7, проверка 5 < x вернет True, проверка x < 10 также вернет True, тем самым мы получим выражение True and True

Помните про круглые скобки из Части 2? Что бы избежать путаницы мы можем применить их:

(5 < x) and (x < 10)
# True

Рассмотрим и другие примеры:

5 < x or x < 10
# True

5 < x and x > 10
# False

5 < x and not x > 10
# True

Python по мимо проверки оператора and, также позволяет следующее:

5 < x < 10
# True

Это выражение аналогично этому - 5 < x and x < 10, мы также можем писать более длинные сравнения:

5 < x < 10 < 999

Истина

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

• булево значение False;
• ​значение None;
  ​- целое число 0;
  ​- число с плавающей точкой 0.0;
  ​- пустая строка '';
  ​- пустой список [];
• пустой кортеж ();
  ​- пустой словарь {};
  ​- пустое множество set();

Все остальные значения приравниваются к True. Язык Python использует эти правила, чтобы определять ложность или истинность объектов и, в частности, выполнять проверки на пустоту коллекций. Посмотрим на пример:

items = []

if items:
    print('Лист не пустой!')
else:
    print('Лист пуст!')

В этом коде пустой список items интерпретируется как False, поэтому срабатывает ветка else и выводится сообщение о том, что список пуст.

Оператор in - несколько сравнений

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

letter = 'о'
if (letter == 'а' or letter == 'е' or letter == 'ё' or letter == 'и' or 
    letter == 'о' or letter == 'у' or letter == 'ы' or letter == 'э' or 
    letter == 'ю' or letter == 'я'):
    print(letter, '- гласная')
else:
    print(letter, '- согласная')

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

vowels = 'аеёиоуыэюя'
letter = 'о'

print(letter in vowels)  # True

if letter in vowels:
    print(letter, '- гласная')

Дополнительно рассмотрим примеры использования in с другими типами данных:

letter = 'о'
vowel_set = {'а', 'е', 'ё', 'и', 'о', 'у', 'ы', 'э', 'ю', 'я'}
print(letter in vowel_set)  # True

vowel_list = ['а', 'е', 'ё', 'и', 'о', 'у', 'ы', 'э', 'ю', 'я']
print(letter in vowel_list)  # True

vowel_tuple = ('а', 'е', 'ё', 'и', 'о', 'у', 'ы', 'э', 'ю', 'я')
print(letter in vowel_tuple)  # True

vowel_dict = {'а': 'яблоко', 'е': 'слон', 'и': 'импала', 'о': 'оцелот', 'у': 'единорог'}
print(letter in vowel_dict)  # True (проверяет ключи)

vowel_string = 'аеёиоуыэюя'
print(letter in vowel_string)  # True

В случае со словарем оператор in проверяет только ключи (слева от двоеточия)

Оператор-морж

С версии Python 3.8 (кстати, я не застал ранние версии, так что морж для меня по умолчанию - часть синтаксиса) выглядит так:
имя := выражение

Для присваивания с проверкой обычно нужно два шага:

text_limit = 280
text_string = "Куку" * 50

diff = text_limit - len(text_string)

if diff >= 0:
    print('В пределах нормы')
else:
    print('К сожалению очень много символов', abs(diff))

Для тех, кто в танке и не поймет с первого раза, почему нет явной проверки на лимит символов: в diff мы задаем 280 - len(text_string). Если в text_string 320 символов, то 280 - 320 = -40. Условие if diff >= 0 не сработает, выполнится else.

Вернемся к оператору-моржу, с его помощью мы можем два шага объединить в один:

text_limit = 280
text_string = "Куку" * 50

if diff := text_limit - len(text_string) >= 0:
    print("В пределах нормы")
else:
    print("К сожалению очень много символов", abs(diff)

Оператор морж := присваивает значение переменной diff и сразу проверяет условие в if. По сути тоже самое что и отдельно присвоить переменной diff значения, только внутри if. По мимо if оператор-морж также используется в циклах for и while о них мы поговорим чуть позднее.

В этой части материала мы познакомимся более подробно с типизацией Python, а именно:

• булевые значения - true/false
• целы числа - int
• числа с плавающей точкой - float

Булевы значения

Одним из самых главных типов являются булевы значения и Python не исключения. Булевы имеются всего два - true и false.
В Python есть даже специальная функция bool() которая умеет преобразовывать любой другой тип в булев.

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

Давайте рассмотрим на примере для ненулевых числе:

bool(True)
# True
bool(1)
# True
bool(35)
# True
bool(-45)
# True

Во всех этих примерах функция bool() вернет нам значение True даже для отрицательных чисел.

А вот с нулевыми значениями дела обстоят иначе:

bool(False)
# False
bool(0)
# False
bool(0.0)
# False

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

Про числа литералы

Любая последовательность чисел в Python будет число-литерал, для примера:

5
# 5
0
# 0

Обратите внимание что таже 0 будет числом литералом, но не стоит ставить его перед другими цифрами иначе мы получим синтаксическую ошибку:

05
# File "<stdin>", line 1
# SyntaxError: invalid token

Также отмечу что любая последовательность цифр будет указывать на целое число и даже если мы поместим знак + перед цифрами то число останется прежним:

123
# 123
+123
# 123

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

-123
# -123

Также есть ограничения на запятые, нельзя их использовать при записи целого числа:

1,000,000
# (1, 0, 0)

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

million = 1_000_000
million
# 1000000

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

1_2_3
# 123

Операции с целыми числами

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

• • сложение
• • вычитание
• • умножение
• / Деление с плавающей точкой
• // Целочисленное деление
• % Вычисление остатка
• ** Возведение в степень

Сложения и вычитания работают так как мы этого и ожидаем:

5 + 10
10

1000 - 7
993

5 - 10
-5

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

10 + 10 - 5
15

5 + 10 - 10 + 15
20

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

10+5       + 5
20

Умножение также работаем как мы этого ожидаем:

5 * 2
10

5 * 3
15

5 * 4
20

А теперь к самому интересному, в Python есть два вида деления:

1. При помощи оператора / выполняются деления с плавающей точкой
2. С помощью оператора // выполняются целочисленные деления (деления с остатком)

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

9 / 4
2.25

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

9 // 4
2

Целые числа и переменные

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

x = 100
x
# 100

x - 5
# 95

Ранее в 1-й части мы говорили про переменные, x - это имя которое указывает на целочисленный объект, в нашем случае это 100. Но когда мы выполняем операцию x - 5, то мы не присваиваем новое значение для переменной x, и ее значение остается неизменным.

x
# 100

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

x = x - 5
x
# 95

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

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

• Вычитаем 5 из x
• Присваиваем результат временной переменной
• Присваиваем x значение временной переменной

Вот как это можно описать в коде:

x = 100
y = x - 5
x = y

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

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

x -= 5
# Такое выражение аналогично - x = x - 3

Аналогично будет и с оператором +:

x += 5
x
# 105

И с оператором умножения *:

x *= 2
x
# 200

А вот пример с оператором деления /:

x /= 3
x
# 33.333333333333336

И наконец попробуем целочисленное деление //:

x //= 3
x
# 33

Теперь поговори об операторе - % он же вычисляет остаток от деления первого числа:

10 % 4
# 2

Есть одна интересная встроенная функция - divmod(a,b) он умеет определять не только остаток, но и частное:

divmode(10,4)
# (2,2)

Достаточно удобная функция, так как она заменяет операции по отдельности:

10 // 4
# 2

10 % 4
# 2

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

Последняя математическая функция которую мы рассмотрим позволяет работать как с целыми числами, так и с плавающей точкой и называется это - возведением в степень или оператор **:

2 ** 5
# 32

2.0 ** 5
# 32.0

2 ** 5.0
# 32.0

Приоритет операций

Теперь рассмотрим с вами приоритетность операций, давайте попробуем вывести следующее выражение:

2 + 2 * 4
# 10

Если мы выполним сложение первым то получим следующее: 2+2=4, а 44=16, но если мы выполним умножение первым: 24=8 и 2+8=10. В языке Python как и почти во всех умножение имеет высокий приоритет в отличии от сложения.

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

2 + (2 * 4)

А вот еще пример с возведениями в степень:

-4 ** 2
# -16

Его можно записать так:

- (4 ** 2)
# -16

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

(-4) ** 2
# 16

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

Системы счисления

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

Десятичная похожа на двоичную, но с нюансами. В двоичной 1 + 1 даст ответ 10, потому что это одна “единица двойки” плюс ноль единиц.

В Python поддерживаются ещё три варианта - с префиксами:

• 0b или 0B - двоичная
• 0o или 0O - восьмеричная
• 0x или 0X - шестнадцатеричная

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

Интерпретатор покажет их в десятичном виде. Давай проверим на примерах:

10
# 10 (десятичное)

Двоичное:

0b10
# 2

Восьмеричное:

0o10
# 8

Шестнадцатеричное:

0x10
# 16

Также существует обратная конверсия - из числа в строку нужной системы:

val = 65
bin(val)
'0b1000001'
oct(val)
'0o101'
hex(val)
'0x41'

Плюс chr() - число в символ:

chr(65)
'A'

И ord() - наоборот:

ord('A')
# 65

Преобразование типов

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

Давай рассмотрим пример на булев, наверное вы уже догадываетесь что True = 1, а False = 0. Давайте убедимся в этом:

int(True)
# 1
int(False)
# 0

Аналогично int() есть функция bool() которая возвращает булев эквивалент целого числа:

bool(1)
# True
bool(0)
# False

Рассмотрим пример с плавающими точками, функция int() просто отсекает все что находится после точки:

int(98.6)
# 98
int(1.0e4)
# 10000

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

bool(1.0)
# True
bool(0.0)
# False

А вот так выглядит преобразование строк в целочисленные числа:

int('99')
# 99
int('-23')
# -23
int('+12')
# 12
int('1_000_000')
# 1000000

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

int('10', 2) # двоичная
# 2
int('10', 8) # восьмеричная
# 8
int('10', 16) # шестнадцатеричная
# 16

Также можно попробовать преобразовать целое числа в целое число, но это ничего не даст, но также и и не навредит:

int(123)
# 123

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

int('hello!')

Правило функции int()- int не будет преобразовывать строки в числа.

Преобразования числе с плавающей точкой

Как и с функций int() ей есть аналог для числе с плавающей точкой и называется она точно также как и тип - float(), разу же рассмотрим пример:

float(True)
# 1.0
float(False)
# 0.0

Преобразование целых числе типа int, через float добавится просто десятичная точка:

float(20)
# 20.0
float(33)
# 33.0

Аналогично можно конвертировать и строки:

float('1.1')
# 1.1
float('-2.4')
# -2.4

И на последок - язык Python поддерживает многие математические функции, таких как косинусы, квадратные корни и многое другое. Их мы будем разбирать отдельно в будущих частях обучения, а также затронем такие библиотеки как math и cmath.

Эта часть будет довольно теоретическая, но ее следует прочитать внимательно и вникнуть.

В Python данные являются объектами, память любого компьютера можно визуально представить в виде длинного ряда полок. Каждый слот имеет ширину в 1 байт (8 бит), если не знакомы с базовой информатикой не забивайте голову.

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

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

Программа хранит информацию о том, где в памяти расположены её данные и какого они типа. С точки зрения самих ПК все биты одинаковые.

В Python каждый тип данных представлен собственным объектом в памяти: bool, int, str, float, а также функции и другие сущности.

А теперь коротко про каждый из типов:

• bool - логический тип: хранит только два значения True и False (удобен для условий и флагов).

• int - целые числа без дробной части; поддерживает числа произвольной длины и обычные операции (+, -, *, //, %).

• float - числа с плавающей точкой (дробные); это приближённые значения, поэтому возможны эффекты округления в вычислениях.

• complex - комплексные числа вида a+bja+bj (в Python мнимая единица - j); применяются в математике/сигналах и т.п.

• str - строка (текст), последовательность символов; неизменяемая, поэтому любые “правки” создают новую строку.

• list - список, упорядоченная изменяемая коллекция; можно добавлять/удалять элементы и менять по индексу.

• tuple - кортеж, упорядоченная неизменяемая коллекция; часто используют для “записей” (наборов значений) и как ключи словаря (если элементы тоже неизменяемые).

• bytes - неизменяемая последовательность байтов (0–255); удобно для бинарных данных (файлы, сети, хэши).

• bytearray - изменяемая версия bytes; удобно, когда нужно редактировать бинарные данные “на месте”.

• set - множество: неупорядоченная коллекция уникальных элементов; быстро проверять “есть ли элемент” и делать операции множеств (объединение/пересечение).

• frozenset - неизменяемое множество; можно использовать там, где требуется хэшируемость (например, как ключ словаря).

• dict - словарь “ключ → значение”; основная структура для отображений, конфигов, JSON-подобных данных и быстрого доступа по ключу.

Переменные

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

Но у Python имеются свои правила написания переменных и могут содержать только следующие символы:

• буквы в нижнем регистре от a до z
• буквы в верхнем регистре от A до Z
• цифры от 0 до 9
• нижнее подчеркивание (_)
• чувствительность к регистру: name, Name, NAME - будут разными именами
• начинаются с буквы или нижнего подчеркивания, но не с цифры
• имена не должны совпадать с зарезервированными словами самого Python

Ниже список зарезервированных слов:

На заметку: что бы увидеть список этих слов, внутри интерпретатора введите команду help("keywords") или import keywords

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

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

x = y + 10

Решить уравнение можно подставив какое либо значение для y, к примеру подставим число 5:

y = 5
x = y + 10
y
15

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

Переменные - это имена, а не ячейки памяти

Одна важная отличительная особенность Python от других языков, что операция присваивания = не копирует значение, а лишь прикрепляет имя к объекту. Такой подход экономит время, но у него есть свои недостатки. Для сравнения с языком C, у Python скорость работы ниже, так как под капотом он заставляет компьютер выполнять больше работы для того что бы нам не пришлось выполнять ее самостоятельно.

Пример:

a = 7
print(a)
7

b = a
print(b)

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

Для проверки типов у Python есть внутренняя функция type():

type(7)
<class int>

А для проверки указывает ли переменная на объект определенного типа используется конструкция isinstance(type) которая принимает два аргумента:

isinstance(7, int)
True

Вы наверное заметили ключевое слово class - это определение объекта, их мы гораздо рассмотрим позже.

Особенности переменных

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

two = qwe = zxc = 2

Еще одной из особенностью является копирование, если мы присвоим существующей переменной a новой переменной b то питон будет указывать на тот же объект что и a
Для наглядного примера взглянем на следующий код:

a = 5
b = a

И если мы попробуем вывести переменную b то получим в ответ 5.

А теперь давайте сделаем ситуацию чуть запутаннее:

a = 5
b = a

a = 10
a
# 10

b
# 5

Давайте разберемся что выведет наш код, при выполнении a = 5 создается объект со значением 5, и имя a начинает ссылаться на него. Затем строка b = a делает то же самое - теперь и a, и b указывают на один и тот же объект 5.
Когда мы выполняем a = 10, имя a просто переназначается и начинает ссылаться на другой объект - число 10.
Переменная b при этом остается связанной с прежним объектом 5, поэтому вывод b даст 5, а a - 10.

Таким образом переменные - это не изменяемый тип.

А теперь рассмотрим списки, или по другому изменяемый массив значений. В качестве примера у нас будет a и b которые будут указывать на список с 3 числами:

a = [2, 4, 6]
b = a
a
# [2, 4, 6]

b
# [2, 4, 6]

Элементы списка/массива a[0], a[1], a[2] сами по себе являются именами которые в свою очередь указывают на числа со значениями 2, 4 и 6. Подмечу что список хранит данные в заданном порядке.

А теперь давайте попробуем изменить первый элемент списка при помощи имени a и посмотрим что выведет список b:

a[0] = 10
a
# [10, 4, 6]
b
# [99, 4, 6]

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

Правила написание имени переменных

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

Для того что бы начать работать с Python, его необходимо установить. Я не буду уделять этому много времени, вы можете самостоятельно установить его под любую операционную систему с официального сайта - https://www.python.org/downloads/

Также нам понадобится IDE для работы с кодом, эпоха VS code прошла, по этому я рекомендую редактор нового поколения - ZED.

Работать через IDE удобно, так как у нас будет сразу же терминал и редактор кода в одном месте:

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

mkdir project

Отлично, теперь после создания папки давайте перейдем в нее написав в терминале cd project. Теперь необходимо создать файл с которым мы будем работать для этого используем команду touch аргументом выступает наименование файла:

touch main.py

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

Виртуальное окружение venv

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

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

pip install virtualenv

Далее создадим само виртуальное окружение, по стандарту оно называется venv, но мы можем использовать другое наименование к примеру project

python3 -m venv project

После установки, нам необходимо активировать окружение.

source project/bin/activate

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

Теперь давайте выйдем из него, для этого напишем в терминале deactivate:

deactivate

Так это выглядит в терминале.

Виртуальные окружения в Python решают проблему конфликтов зависимостей: каждый проект получает изолированный site-packages.

Пример: legacy-проект на Django 2.2 с mysqlclient==1.4.0, новый — на Django 4.1 с asyncpg. Без venv pip install django==4.1 сломает первый проект.