Python
Python - это интерпретируемый, высокоуровневый, язык программирования общего назначения.
Python - объектно-ориентированный язык программирования. Все сущности в Python - объекты, экземпляры того или иного класса. Класс - это шаблон или прототип для создания объектов. На основании одного класса можно создать много разных объектов. Например: клас integer, класс string, класс float.
У каждого объекта есть атрибуты. При этом, атрибут объекта называется методом, если его значение - функция. Метод, как любую функцию, можно вызвать.
Имена в Python
- snake_case - используется для определения переменных, функций
- PascalCase - используется для определения классов
- my-packages - используется для наименования пакетов
- DB_CONST - используется для определения констант
- В названиях переменных рекомендуется использовать имя существительное. Названия переменных должны быть понятны, т.е. выражать смысл того, что в переменную записано. Имя переменной должно отвечать на вопрос "что содержит"
- Названия функций и методов следует начинать с глагола. Имя функции должно отвечать на вопрос "что выполняет или возвращает"
Переменные
Переменная — это имя, указывающее на какое-то значение. Типизация переменных языка Python динамическая. На практике это означает, что им можно повторно присваивать значения, относящиеся к другим типам или классам.
Переменная - инструмент через который происходит обращение к хранящимся в памяти данным. При присвоении переменной значения, интерпритатор находит в памяти ПК свободное место и записывает туда определенное занчение, так же создается метка с именем переменной, которая связывается с адресом значения в памяти. Переменная представляет собой ссылку на объект в памяти. При обращении к переменной происходит переход к объекту, который находится в памяти. Если переменную переопределить она просто начнет ссылаться на другой объект в памяти, а старый объект будет со временем удален. Несколько переменных могут ссылаться на один и тот же объект в памяти. Например, когда мы присваиваем одной переменной значение другой переменной, мы создаем новую ссылку на старый объект в памяти.
Основные математические операции
Для основных математических операций — существуют встроенные математические операторы:
# Сложение (+):
a = 5
b = 3
result = a + b
print(result) # Выведет 8
# Вычитание (-):
result = a - b
print(result) # Выведет 2
# Умножение (*):
result = a * b
print(result) # Выведет 15
# Деление (/):
result = a / b
print(result) # Выведет 2.5
# Целочисленное деление (//):
result = a // b
print(result) # Выведет 2
# Возведение в степень (**):
result = a ** b
print(result) # Выведет 8
# Остаток от деления (%):
result = a % b
print(result) # Выведет 1
Контроль выполнения
В языке Python есть множество конструкций для управления потоком выполнения операторов. Операторы, которые нужно выполнять вместе, можно группировать в блоки кода, которые можно выполнять многократно с помощью циклов for и while либо только при определенных условиях с помощью оператора if, цикла while или блоков try-except.
В различных языках программирования разграничение блоков кода определяется разными соглашениями. В Python для этой цели применяются отступы. Операторы группируются по числу отступов в блоки, выполняемые как единое целое.
if_else
Операторы if/elif/else — распространенное средство выбора веток кода. Следующий непосредственно за оператором if блок кода выполняется, если значение условия оператора равно True.
За этим блоком может следовать необязательный оператор elif или else со своим блоком, который в случае оператора elif выполняется, только если условие elif равно True. При желании можно расположить друг за другом несколько выражений elif.
Добавление оператора else в конце позволяет выполнять блок только в том случае, если ни одно из предыдущих условий не равно True.
Операторы if могут быть вложенными, с содержащими операторы if блоками, которые выполняются только в том случае, если условие во внешнем операторе if равно True
print('Enter i')
i = int(input())
if i == 45:
print('i is 45')
elif i == 35:
print('i is 35')
elif i > 10:
print('i is greater than 10')
elif i%3 == 0:
print('i is a multiple of 3')
else:
print('I don't know much about i...')
for
Циклы for позволяют повторять выполнение блока операторов (блока кода) столько раз, сколько содержится элементов в последовательности (упорядоченной группе элементов). При проходе в цикле по последовательности блок кода обращается к текущему элементу. Чаще всего циклы используются для прохода по объекту range для выполнения какой-либо операции заданное число раз.
continue
Оператор continue позволяет пропустить один шаг в цикле и перейти сразу к очередному элементу последовательности:
while
Цикл while повторяет выполнение блока кода до тех пор, пока условное выражение равно True:
Главное — задать условие выхода из такого цикла, в противном случае он будет выполняться до тех пор, пока программа не завершится аварийно. Для этого можно, например, задать такое условное выражение, которое в конце концов окажется равным False. Либо воспользоваться оператором break для выхода из цикла с помощью вложенного условного оператора
try_except
Обработка исключений
Исключения — ошибки, которые могут привести к фатальному сбою программы, если их не обработать должным образом (перехватить). Благодаря их перехвату с помощью блока try-except программа может продолжить работу.
Для создания такого блока необходимо добавить отступы к блоку, в котором может возникнуть исключение, поместить перед ним оператор try, а после него — оператор except. За ним будет следовать блок кода, который должен выполняться при возникновении ошибки:
try: # блок, в котором выполняется основной код
some_code
except ZeroDivisionError as e: # отлавливаем ошибку по определенному типу
print(e) # печатаем тип ошибки
except Exception as e: # отлавливаем всевозможные типы ошибок
print(e) # печатаем тип ошибки
except: # просто выполняем блок кода при возникновении ошибки
print("Some error Occurred")
else: # не обязательный блок
some_code # если не возникло ошибок
finally: # не обязательный блок
some_code # выполняется в любом случае
other_code
При возникновении ошибки в блоке try управление будет передано в блоки except и, если возникла ошибка указанная в этих блоках, будет выполнено тело соответствующего блока except и программа продолжит выполнять дальнейший код. Если же возникнет ошибка не указанная в блоках except - программа остановиться.
Основный типы в Python
integer
Целые числа Integer
int 100500 -100 0 - integer, целое число.
x = 100500
y = -100
z = 0
# Определить тип
type(x) # <class 'int'>
# Преобразовать тип
int("123") # 123
int(3.7) # 3
int(True) # 1
int("101", 2) # 5
int_var = int(input())
# С помощью данного выражения можно присвоить переменной int_var целое число введенное в терминал.
# #Что именно происходит при выполнении данного выражения:
# функция input() возвращает строковый объект из терминала и передает его функции - > int(),
# далее функция переводит строковый тип в целое число (если это возможно), и возвращает значение - >
# которое присваивается переменной int_var
Длинные целые числа можно записывать используя знаки подчеркивания, например: 1_000_000, python будет интерпритировать их как простые целые числа
bool
Логический тип bool. bool - это подкласс int
float
Вещественные цисла с плавающей точкой.
Последовательности
Последовательности — семейство встроенных типов данных, включающее списки (list), кортежи (tuple), диапазоны (range), строковые значения (string) и двоичные данные (binary). Последовательности служат для представления упорядоченных конечных последовательностей элементов.
Операции над последовательностями
# С помощью операторов in и not in можно проверить, входит ли конкретный элемент в последовательность
2 in [1,2,3]
True
'a' not in 'cat'
False
10 in range(12)
True
10 not in range(2, 4)
True
Ссылаться на содержимое последовательности можно по индексу. Для доступа к элементу, расположенному по какому-либо индексу, используются квадратные скобки с этим индексом в качестве аргумента. Индекс первого элемента — 0, второго — 1 и так далее вплоть до номера, на единицу меньшего, чем число элементов.
Индексацию можно выполнять и с конца последовательности, а не с ее начала, указывая в качестве индекса отрицательные числа. Индекс последнего элемента -1, предпоследнего — -2 и т. д.
Индекс элемента можно узнать с помощью метода index, который по умолчанию возвращает индекс первого вхождения конкретного элемента, но с помощью необязательных аргументов можно задать поддиапазон для поиска.
my_sequence = "Bill Cheatham"
my_sequence.index('C')
5
my_sequence.index('a')
8
my_sequence.index('a',9, 12)
11
my_sequence[11]
'a'
Срезы
Создать новую последовательность на основе существующей можно с помощью срезов. Получить срез заданной последовательности можно ее вызовом с указанием в квадратных скобках необязательных аргументов start, stop и step:
my_sequence[start:stop:step]
# start — индекс первого элемента новой последовательности,
# stop — первый индекс за ее пределами, а
# step — расстояние между элементами.
# Все эти аргументы необязательны, если они не указаны, то заменяются значениями по умолчанию.
# В результате выполнения этого оператора генерируется копия исходной последовательности.
# Значение по умолчанию для start — 0, для stop — длина последовательности, а для step — 1.
# если step не указан, то соответствующий символ : также можно опустить
my_sequence = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
my_sequence[2:5]
['c', 'd', 'e']
my_sequence[:5]
['a', 'b', 'c', 'd', 'e']
my_sequence[3:]
['d', 'e', 'f', 'g']
Существует множество операций для получения информации о последовательностях и их содержимом.
- len возвращает длину последовательности,
- min — наименьший элемент,
- max — наибольший элемент,
- count — номер конкретного элемента в ней.
Операции min и max применимы только к последовательностям, элементы которых сравнимы между собой.
string
Строки
Строка - это упорядоченная последовательность символов. Строки могут быть многострочными, для их создания используются тройные кавычки. text = """some text here"""
# Создавать строковые значения можно либо с помощью метода-конструктора для строк str(), либо просто заключая текст в кавычки:
str()
len("string") # Встроенная функция, которая возврашает длину строки
# Поскольку строка - это упорядоченная последовательность символов, к любому символу можно обратиться, как к элементу списка, используя [ ]. Например:
string[0] # вернет первый символ строки;
string[3:9] # вернет символы с 4-го по 8-й.
# Соединение строк:
# С попощью опреатора +, будет вызван магический метод __add__, который соединит два и более объекта str
new_string = string1 + string2
# С помощью f-строк.
new_string = f"{var_string1} some_text {var2} some_text {fn1}"
Методы для строк
В начале или в конце пользовательского текста нередко встречаются пробелы. А введенную пользователем строку " да" желательно обрабатывать так же, как и "да". На этот случай в строках Python есть метод strip(), который возвращает строку без пробелов в начале или в конце. Существуют также методы для удаления пробелов только с правой или левой стороны строки: rstrip(), lstrip().
input = ' I want more '
input.strip()
'I want more'
input.rstrip()
' I want more'
input.lstrip()
'I want more '
В то же время существуют методы ljust() и rjust() для дополнения строк символами. По умолчанию они дополняют строковые значения пробелами, но могут и принимать в виде аргумента символ для дополнения:
Иногда бывает нужно разбить строковое значение на список подстрок, скажем превратить предложение в список слов или строку слов, разделенных запятыми. Метод split() разбивает строку, преобразуя ее в список строк. По умолчанию в качестве токена, на основе которого выполняется разбиение, используется пробел. Для разбиения по другому символу можно добавить необязательный аргумент:
text = "Mary had a little lamb"
text.split()
['Mary', 'had', 'a', 'little', 'lamb']
url = "gt.motomomo.io/v2/api/asset/143"
url.split('/')
['gt.motomomo.io', 'v2', 'api', 'asset', '143']
list
Списки
list [1, 2, 3] - список. В списке можно сохранять элементы разных типов: числа, строки и пр. На синтаксис списка указывают квадратные скобки.
Список - упорядоченная последовательность элементов. У каждого элемента списка есть свой уникальный индекс, индексы начинаются с 0. Обращение к элементу списка происходит по его индексу, так же меняются значения элементов списка. Элементы списка можно удалять используя оператор del имя_списка[индекс].
# Для создания пустого списка или списка на основе другого конечного итерируемого объекта (например, другой последовательности) можно задействовать функцию list():
list()
[]
list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
my_list = [] # пустой список
Элементами списка могут быть словари. список = [{'ключ1': значение1}, {'ключ2': значение2}, {'ключ3': значение3}]. К значению ключа в словаре можно обратиться следующим образом: список[1] ['ключ2'] выдаст значение2
Элементами списка погут быть переменные.
# У объектов класса список существуют много методов. Например:
my_list = [1, 2, 3]
my_list.append(1) # вызывает метод, который добавляет новый элемент в конец списка.
my_list.insert(1, 'one') # вызывает метод, который добавляет новый элемент.
my_list.pop() # вызывает метод, который удаляет последний элемент списка.
my_list.pop(2) # вызывает метод, который удаляет элемент списка с индексом 2.
my_list.remove(3) # вызывает метод, который удаляет первое вхождение указанного элемента списка.
my_list.sort() # вызывает метод, который сортирует существующий список по порядку.
my_list.sort(reverse=True) # вызывает метод, который сортирует существующий список в обратном порядке.
# Списки можно объединять использую для этого оператор сложения, при этом будет вызван магический метод.
# С помощью метода extend можно добавить содержимое одного списка в конец другого
my_list1.extend(my_list2)
# Списки можно нарезать, так же строки
Списковые включения
Одна из самых впечатляющих характерных возможностей Python — списковые включения — позволяет использовать функциональность цикла for с помощью одной строки кода.
# Рассмотрим простой пример — возведение чисел от 0 до 9 в квадрат в цикле for и добавление их в конец списка:
squares = [i*i for i in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# Обратите внимание на то, что сначала указывается функциональность внутреннего блока кода, за которой следует оператор for.
# В списковых включениях можно использовать условные операторы для фильтрации результатов:
squares = [i*i for i in range(10) if i%2==0]
[0, 4, 16, 36, 64]
# Копировать список можно следующим образом:
new_list = old_list[:] # это копирование использую нарезку,
# при этом в памяти будет создан новый объект класса список на который указывает переменная новый_список.
new_list = old_list.copy() # это копирование списка с помощью метода copy().
# Это наиболее предпочтительный метод копирования списка, поскольку используется очевидный метод.
new_list = list(old_list) # это копирование списка с помощью функции конвертации list()
# Распаковка списков, применяется когда нужно получить быстрый доступ к отдельным элементам списка, назначив значения определенным переменным
my_list = ['one', 'two', 'three']
a, b, c = my_list # последовательно присвоит значения элементов списка переменным a, b, c,
dict
Словари или Ассоциативные массивы
Ассоциативный массив задает соответствие ключей значениям. Поиск конкретного значения по ключу производится очень быстро и эффективно. Ключами могут быть строки, числа, пользовательские объекты и любые другие неизменяемые типы.
Изменяемый (mutable) объект — такой, содержимое которого может меняться после создания. Основной пример — списки: содержимое списка может меняться без изменения его самого. Строковые значения — неизменяемые. Всякий раз, когда меняется содержимое уже существующей строки, создается новая.
Словарь - это последовательность сопоставлений. Словарь похож на список, но более универсальный. В списке индексы должны быть целыми числами; в словаре же они могут быть почти любого типа.
Словарь - набор элементов ключ: значение. Каждый ключ связан с одним значением. Значения ключей могут быть разных типов. Имя ключа должно быть уникально. Элементы словаря не имеют индексов. Поскольку словарь не имеет целочисленных индексов, порядок ключей в словарях не играет роли, поэтому при сравнении двух разных словарей с одинаковыми значениями элементов, которые по разному упорядоченны, python будет считать, что словари одинаковые.
dict {'one': 1, 'two': 2, 'three': 'три'} # словарь, состоит из элементов.
# Каждый элемент списка - это сущность-пара, которая состоит из 'ключа': значения.
map = dict() # создаем пустой словарь
map = {'key-1': 'value-1', 'key-2': 'value-2'} # создаем словарь со значениями
map['key'] # обращаемся к значению ключа key
map['new_key'] = value # добавляем новый элемент ключ-значение в словарь
del map['key'] # удаляет пару ключ-значение
print(map.get('key')) # используя метод get для вывода значения ключа можно избежать остановки выполнения программы из-за несуществующего элемента словаря.
map.keys() # Метод keys() возвращает объект dict_keys, содержащий все ключи ассоциативного массива
map.values() # Метод values() возвращает dict_values, содержащий все значения ассоциативного массива
map.items() # метод items() — пары «ключ/значение».
# Печатаем словарь красиво
for key, value in map.items():
print(f"{key}: {value}")
# Оператор распаковки словаря **
# С его помощью можно создать новый словарь из старого словаря и добавить к нему необходимые элементы.
new_dict = {**old_dict, 'new_key': new_val}
new_dict = {**old_dict1, **old_dict2} # можно объединять словари
new_dict = old_dict1 | old_dict2 # тоже объединяет словари через pipe (доступно с вер. python 3.9.0)
tuple
Кортежи
Кортеж (tuple) - упорядоченная последовательность элементов. Кортежи нельзя изменять. Элементами кортежа могут быть объекты разных типов, которые размещаются в круглых скобках. К элементам кортежа можно обращаться по индексу, как к элементам списка: tuple[1].
Кортежи изменять нельзя, но можно изменять элементы внутри изменяемых элементов кортежа. Например, если кортеж состоит из списков или словарей можно менять элементы вложенных списков и словарей.
Если очень нужно изменить кортеж, можно действовать следующим образом: конвертировать кортеж в список -> изменить полученный список -> конвертировать измененный список в кортеж.
Функция zip
Применяется для объединения упорядоченных последовательностей, путем создания последовательности кортежей. Каждый н-ый кортеж последовательности составлен из н-ных элементов объединяемых последовательностей. Длина итоговой zip-последовательности определяется длиной найменьшей из последовательностей.
Необходимо отметить: объект zip является итератором, а итераторы в Python организованы таким образом, что они выполняют итерацию только один раз и не сохраняют состояние после процесса итерирования. Полученную zip-последовательность можно итерировать в цикле, а можно конвертировать в список и пр.
set
Наборы
Набор (set) - неупорядоченная последовательность элементов, следовательно у элементов нет индексов. Набор содержит только уникальные элементы. Наборы можно изменять. В наборах принято сохранять однотипные данные, например: числа; при этом, в набор нельзя добавлять объекты изменяемых классов, таких как: списки, словари, наборы. Что бы поддерживать уникальность каждого элемента набора, python для каждого элемента создает уникальный hash, по которому и проверяется уникальность.
my_set = {1, 2, 3, 4, 5}
my_set.add(6) # метод add добавляет элемент в набор
my_set = my_set1.union(my_set2) # метод union ( | ) объединяет два набора, удаляя дубликаты элементов из нового набора
intersection ( & ) # метод находит пересечение двух наборов, оставляет только одинаковые элементы
issubset # метод проверяет включен ли один набор в другой
range
Диапазоны
Дмапазон (range) - упорядоченная неизменяемая последовательность уникальных элементов. Диапазоны обычно используются в циклах. Диапазон состоит из целых чисел от начального элемента до конечного с определенным шагом. Диапазон можно легко перебирать итеративным методом.
При вызове конструктора range() возвращается представляющий последовательность чисел объект. Функция range принимает до трех целочисленных аргументов. При указании лишь одного аргумента последовательность состоит из чисел от нуля до этого аргумента, не включая его. Второй аргумент (при его наличии) отражает точку, с которой вместо нуля начинается последовательность. Третий аргумент служит для указания шага последовательности, по умолчанию равен 1.
Требования к оперативной памяти функции range невелики даже для больших последовательностей, ведь хранить нужно только значения начала, конца и шага последовательности. Функция range может проходить по большим последовательностям чисел без снижения быстродействия.
Конвертация типов
Python не выполняет неявную конвертацию типов значений. Т.е.: чтобы выполнить сложение (вычитание и пр.) объектов принадлежащих разным классам их необходимо конвертировать в один тип. Например, выражение 5 + '10' не будет выполненно, необходимо явно конвертировать 5 в строку str(5), либо '10' в число int('10'), тогда все получится.
Примеры втроенных функций для явной конвертации:
str(в строку), float(в нецелое число), tuple(в кортеж), int(в целое число), list(в список), set(в набор).
Однако, иногда может показаться, что python производит неявную конвертацию при выполнении некоторых выражений, но это только кажется. Например! а = 5 + 5.5. Теоретически, чтобы присвоить переменной а результат выражения 5 + 5.5, необходимо произвести конвертацию целого числа 5 в десятичное число 5.0. Но такую конвертацию можно сделать только явным образом, т.е.: a = float(5) + 5.5. Тем не менее, результат выполнения выражения 5 + 5.5 будет верным, но за счет вызова магического метода __add__ для класса int, которорый не сможет успешно отработать и вернет значение NotImplemented, получив такой ответ, python поменяет объекты выражения местами и вызовет другой магический метод __radd__ для класса float, который конвертирует объект (целое число) в класс десятичных чисел, затем произведет требуемую операцию сложения и выдаст верное значение.
Магические методы - это внутренние методы класса, они обычно не вызываются явно.
Функция
Функция — это механизм инкапсуляции блока кода, позволяющий воспроизводить поведение этого блока в различных местах без дублирования самого кода.
# Пример синтаксиса простой функции
def my_fn(arg1, arg2): # имя функции и параметры
sum = arg1 + arg2 # тело функции
return sum # возвращаемое значение
Встроенный в python функции.
input()
# Функция input передает в консоль сообщение и ждет пока пользователь введет что-то в ответ.
# После нажатия Enter возвращает введенную строку в программу.
name = input("Enter your name: ") # передает в переменную введенную с клавиатуры строку
age = int(input("Enter your age: ")) # передает в переменную введенное с клавиатуры число
print()
# Функция print выводит в консоль переданное в нее значение аргументов.
print("Some text") # выводит переданный в функцию тект
print(var_value) # выводит значение переданной в функцию переменной
print("Итог: ", 3 + 5 + var) # выводит значение вычисляемого выражения
random
# Модуль для генерации случайного выбора
import random # необходимо импортировать модуль
my_random = random.randint(0, 2) # функция randint генерирует случайное целое число из указанного диапазона
my_random2 = random.choice(['choice1', 'choice2', 'choice3']) # выбор случайного варианта из списка вариантов
my_random3 = [random.randint(30,60) for _ in range(30)] # генерирует список из 30-ти случайных чисел в диапазоне от от 30 до 60
open(), close(), read(), write()
Функции и методы для работы с файловой системой
# Для открытия файлов используется функция open(), которой передается имя файла и флаг режима доступа (r, w)
my_file = open('some_file.txt', 'r') # функция open() возвращает файловый объект, который записывается в переменную
my_text = my_file.read() # метод read() записывает все содержимое файла в одну строковую переменную
my_line1 = my_file.readline() # метод readline() читает файл построчно
my_line2 = my_file.readline() # при каждои новом вызове readline() будет прочитана новая строка
my_file.close() # метод close() закрывает файл
# Для открытия файлов для записи используется функция open() с флагом (w)
my_file = open('some_file.txt', 'w') # функция open() возвращает файловый объект, если файл не существует он будет создан
my_file.write('my_text') # метод write() записывает значение переменной в файл, предварительно стирая из файла всю хранящуюся в нем информацию
my_file.close() # метод close() закрывает файл
url requests
Модули и функции для обращения к веб-ресурсам
python3 -m pip install requests # необходимо установить пакет requests
response = requests.get(url) # с помощью функции get() можно получить ответ от веб-сервера. ответ будет записан в
# объект-переменную response. Чаще всего, веб-службы дают ответ в формате json
# Созданный для хранения ответа объект response имеет несколько ключевых атрибутов:
response.text # данные ответа, запрашиваемая у веб-службы полезная информация
response.status_code # диагностический код состояния веб-службы (200, 400, etc.)
response.headers # тип содержимого (application/json)
# Простой пример обращения к веб-службе
import requests # импортируем модулль для запросов
url = 'http://api.open-notify.org/iss-now.json' # указываем url веб-службы
response = requests.get(url) # делаем запрос и сохраняем ответ в объект response
if (response.status_code == 200): # если статус-код веб-сервиса положительный
print(response.text) # печатаем текст ответа
else: # в противном случае - печатаем текст ошибки
print("Error code:", response.status_code)
json
Модуль для работы с форматом json