10 |
11 |
--------------------------------------------------------------------------------
/additional_lesson3/ngrok_mini_server.py:
--------------------------------------------------------------------------------
1 | # Воспользуемся сервисом ngrok https://ngrok.com/
2 | # Это инструмент для туннелирования локальных портов
3 | # на общедоступные URL-адреса.
4 |
5 | # Для демонстрации создадим простой локальный сервер,
6 | # доступ к которому и будем туннелировать.
7 | import http.server
8 |
9 |
10 | def run(server_class=http.server.HTTPServer,
11 | handler_class=http.server.SimpleHTTPRequestHandler):
12 | server_address = ('', 8000)
13 | httpd = server_class(server_address, handler_class)
14 | httpd.serve_forever()
15 |
16 |
17 | run()
18 |
19 | # Скачиваем файл ngrok.exe (запакованн в архив) после регистрации аккаунта.
20 | # Разархивируем так, чтоб файл оказался в той же папке, что и файл сервера.
21 |
22 | # Запускаем программу ngrok.exe и в открывшейся консоли вводим команду:
23 | # ngrok config add-authtoken <токен вашего аккаунта ngrok>
24 | # Токен можете посмотреть на сайте в вашем профиле.
25 |
26 | # После привязки профиля к данной программе запускаем туннелирование:
27 | # ngrok http <порт вашего сервера, напр. 8000>
28 |
29 | # Если все шаги выполнены правильно, содержимое терминала изменится.
30 | # Там вы можете найти адрес, по которому доступен ваш сайт в интернете
31 | # в разделе Forwarding. Например:
32 | # Forwarding https://71sa-as1s-123-2321.ngrok-free.app -> http://localhost:8000
33 | # Значит, наш сервер доступен по адресу:
34 | # https://71sa-as1s-123-2321.ngrok-free.app
35 |
--------------------------------------------------------------------------------
/additional_lesson3/requirements.txt:
--------------------------------------------------------------------------------
1 | anyio==4.0.0
2 | certifi==2023.7.22
3 | charset-normalizer==3.2.0
4 | click==8.1.7
5 | colorama==0.4.6
6 | flake8==6.0.0
7 | h11==0.14.0
8 | httpcore==0.17.3
9 | httpx==0.24.1
10 | idna==3.4
11 | mccabe==0.7.0
12 | pycodestyle==2.10.0
13 | pyflakes==3.0.1
14 | PyQt5==5.15.9
15 | pyqt5-plugins==5.15.9.2.3
16 | PyQt5-Qt5==5.15.2
17 | PyQt5-sip==12.12.2
18 | pyqt5-tools==5.15.9.3.3
19 | python-dotenv==1.0.0
20 | python-telegram-bot==20.5
21 | qt5-applications==5.15.2.2.3
22 | qt5-tools==5.15.2.1.3
23 | requests==2.31.0
24 | sniffio==1.3.0
25 | urllib3==2.0.4
26 |
--------------------------------------------------------------------------------
/lesson1/first.py:
--------------------------------------------------------------------------------
1 | print("Текст")
--------------------------------------------------------------------------------
/lesson10/funcs.py:
--------------------------------------------------------------------------------
1 | # Функции - именованная часть кода
2 |
3 | import math
4 |
5 |
6 | CHECK_LIST = ['админ', 'superuser', 'суперадмин'] # константа
7 |
8 |
9 | # access_level = input('Введите ваш уровень доступа: ')
10 | # if access_level in CHECK_LIST:
11 | # print('Доступ разрешен!')
12 | # else:
13 | # print('В доступе отказано!')
14 | # # --------------------------------------------------
15 | # access_level = input('Введите ваш уровень доступа: ')
16 | # if access_level in CHECK_LIST:
17 | # print('Доступ разрешен!')
18 | # else:
19 | # print('В доступе отказано!')
20 |
21 |
22 | # Функция без аргументов
23 | # ШАБЛОН
24 | # def <имя функции>(): # определение функции
25 | # <тело функции> # перечень действий к выполнению
26 |
27 | # <имя функции>() # вызов функции
28 |
29 | def access_check(): # определяем функцию с именем access_check
30 | access_level = input('Введите ваш уровень доступа: ') # тут и ниже тело функции
31 | if access_level in CHECK_LIST:
32 | print('Доступ разрешен!')
33 | else:
34 | print('В доступе отказано!')
35 |
36 | access_check() # вызов функции access_check
37 | # print(access_level) # ошибка, переменная не видна вне функции
38 | access_check() # вызов функции access_check
39 |
40 |
41 | # Функции с неск. аргументами
42 | # ШАБЛОН
43 | # def <имя функции>(<параметры функции>): # определение функции с параметрамиы
44 | # <тело функции> # исполняемая часть
45 |
46 | # <имя функции>(<аргументы функции>) # вызов функции с аргументами
47 |
48 |
49 | def sqrt_with_check(num): # задается 1 параметр - num
50 | if num >= 0:
51 | return math.sqrt(num) # return прерывает выполнение функции и возвращает значение
52 | else:
53 | return 0 # в противном случае команда return вернет значение 0
54 |
55 |
56 | print(round(sqrt_with_check(10), 2)) # вызов функции с одним аргументом
57 | print(sqrt_with_check(-3)) # вызов функции с одним аргументом
58 |
59 |
60 | def greeting(name, surname): # name, surname - параметры
61 | print(f'Здравствуйте, {surname} {name}')
62 |
63 | greeting('Магомед', 'Магомедов') # вызов функции с двумя аргументами
64 |
65 |
66 | # Области видимости - глобальная и локальная
67 | # Глобальная область видимости для переменных, объявленных вне функций
68 | # Локальная область видимости для переменных, объявленных внутри функций
69 |
70 | def incr(num): # объявление функции для инкрементации
71 | # print(num + 1) # переменная num существует только внутри функции
72 | # num_list.append(num + 1) # num_list - глобальная переменная, но изменяется в функции
73 | num_list = [1, 2, 3, 4] # локальная переменная, удалится по завершении функции
74 |
75 |
76 | # print(num)
77 | num_list = [1, 2, 3] # глобальная переменная, т.к. объявлена вне какой-либо функцииы
78 | incr(3) # вызов функции
79 | print(num_list)
--------------------------------------------------------------------------------
/lesson10/list_comprehensions.py:
--------------------------------------------------------------------------------
1 | # Списочные выражения
2 |
3 | # [<выражение> <цикл for>] - упрощенная структура
4 | num_list = [x for x in range(10)] # перебираем в цикле значения x и записываем в список
5 | print(num_list)
6 |
7 | num_list2 = [0 for _ in range(100)] # проходим по итератору и записываем в список значение 0
8 | print(num_list2)
9 |
10 | input_list = [int(input()) for _ in range(4)] # вводим с консоли, преобразуем в int и добавляем
11 | print(input_list)
12 |
13 | # [<выражение> <цикл for> <условие>] - списочное выражение с условием if
14 | num_list3 = [x ** 2 for x in input_list if x > 0] # все непрошедшие проверку условия элементы не добавляются в список
15 | print(num_list3)
16 |
17 | # [<выражение> <условие> <выражение> <цикл for>] - списочное выражение с условием if..else
18 | num_list4 = [x ** 2 if x > 0 else x ** 3 for x in input_list] # в зависимости от условия выполняются разные выражения
19 | print(num_list4)
20 |
--------------------------------------------------------------------------------
/lesson10/repeat.py:
--------------------------------------------------------------------------------
1 | fruits = ['апельсин', 'яблоко', 'дыня']
2 | for fruit in fruits:
3 | print(f'Добавляем {fruit}', end=' | ')
--------------------------------------------------------------------------------
/lesson10/time_module.py:
--------------------------------------------------------------------------------
1 | # time - модуль для работы со временемs
2 | import time
3 |
4 |
5 | print(time.time()) # возвращает текущее время в секундах от 1970, 1 января
6 | print(time.ctime()) # возвращает текущее время и дату в виде строки
7 | time.sleep(3) # замораживает выполнение программы на значение в скобках
8 | print('Подъем!!')
9 |
--------------------------------------------------------------------------------
/lesson11/func_fight.py:
--------------------------------------------------------------------------------
1 | # Пошаговый файтинг с фунциями
2 | import random
3 | import time
4 |
5 |
6 | def create_player(): # функция создания игрока
7 | player = {'жизни': 50} # создаем словарь с данными об игроке
8 | player['имя'] = input('Имя игрока: ') # определяем имя игрока
9 | return player # возвращаем словарь с данными
10 |
11 | def attack(damager, defender): # нанесение урона одним игроком второму
12 | damager['урон'] = random.randint(1, 20) # случайное значение урона у игрока
13 | defender['жизни'] -= damager['урон'] # наносим сопернику урон
14 | print(damager['имя'] + ' нанёс ' + str(damager['урон']) + ' урона.') # информация об нанесенном уроне
15 |
16 | def player_info(player): # информация об оставшихся жизнях игрока
17 | print('У ' + player['имя'] + ' осталось ' + str(player['жизни']) + ' здоровья') # информация об остатках жизней
18 |
19 | def win_check(player1, player2): # проверяем, кто из игроков выжил и победил
20 | if player1['жизни'] <= 0 and player2['жизни'] <= 0: # проверка на ничью
21 | return 'Оба игрока погибли. Ничья.'
22 | elif player1['жизни'] <= 0: # проверка на поражение игрока 1
23 | return player1['имя'] + ' погиб. ' + player2['имя'] + ' победил!'
24 | elif player2['жизни'] <= 0: # проверка на поражение игрока 2
25 | return player2['имя'] + ' погиб. ' + player1['имя'] + ' победил!'
26 |
27 |
28 | player1 = create_player() # создаем первого игрока
29 | player2 = create_player() # создаем второго игрока
30 |
31 | while player1['жизни'] > 0 and player2['жизни'] > 0: # проверка, живы ли бойцы
32 | time.sleep(3) # останавливаем выполнение на 3 секунды
33 | print('----------------Новый раунд----------------')
34 |
35 | attack(player1, player2) # первый игрок атакует второго
36 | attack(player2, player1) # второй игрок атакует первого
37 |
38 | player_info(player1) # информация о первом игроке
39 | player_info(player2) # информация о втором игроке
40 |
41 | print(win_check(player1, player2)) # вывод результата
42 |
--------------------------------------------------------------------------------
/lesson11/palindrome.py:
--------------------------------------------------------------------------------
1 | # Проверка на палиндром
2 |
3 | def palindrome(text=''): # параметру задано значение по умолчанию
4 | return text == text[::-1]
5 |
6 |
7 | print(palindrome('шалаш'))
8 | print(palindrome('текст'))
9 | print(palindrome())
10 |
--------------------------------------------------------------------------------
/lesson11/repeat.py:
--------------------------------------------------------------------------------
1 | def sum_func(x, y):
2 | return x + y # возвращает результат и завершает выполнение функции
3 |
4 |
5 | print(sum_func(5, 15)) # позиционные аргументы
--------------------------------------------------------------------------------
/lesson11/solving_quad_equetion.py:
--------------------------------------------------------------------------------
1 | # Решение квадратного уравнения
2 |
3 | def solve_eq(a=1, b=0, c=0): # значения a, b, c заданы по умолчанию
4 | discr = b ** 2 - 4 * a * c
5 | print('РЕШЕНИЕ')
6 | if discr < 0:
7 | print('У уравнения нет корней.')
8 | return # по умолчанию вернет None
9 | elif discr == 0:
10 | x = -b / (2 * a)
11 | print(f'x = {x:.3f}')
12 | return x
13 | else:
14 | x1 = (-b + discr ** 0.5) / (2 * a)
15 | x2 = (-b - discr ** 0.5) / (2 * a)
16 | print(f'x1 = {x1}\nx2 = {x2}') # \n перевожу второй корень на новую строку
17 | return x1, x2 # вернется кортеж из корней
18 |
19 | solve_eq()
20 |
21 | solve_eq(1, -1, 0) # позиционные аргументы
22 | solve_eq(c=0, b=-1, a=1) # именованные аргументы
23 | solve_eq(1, c=0, b=-1) # позиционные и именованные аргументы
24 |
--------------------------------------------------------------------------------
/lesson12/average.py:
--------------------------------------------------------------------------------
1 | # def avg_func(num_list):
2 | # return sum(num_list) / len(num_list)
3 |
4 |
5 | # print(avg_func([10, 2, 23, 15])) # передаем список как аргумент
6 |
7 | def avg_func(*args): # *args - хранит все позиционные аргументы в форме кортежа
8 | return sum(args) / len(args)
9 |
10 |
11 | print(avg_func(23, 12, 33, 21)) # работает с любым количеством аргументов
--------------------------------------------------------------------------------
/lesson12/cook.py:
--------------------------------------------------------------------------------
1 | # Программа для готовки блюда из ингредиентов
2 |
3 | import random
4 |
5 |
6 | ACTIONS = ['варим', 'жарим', 'парим', 'запекаем'] # константа действий
7 |
8 |
9 | # def cook(*args, sauce='аджика'): # перечень продуктов и соус как значение по умолчанию
10 | def cook(*args, **kwargs): # перечень продуктов и соус через **kwargs
11 | # print(args) # вывели кортеж
12 | # print(kwargs) # вывели словарь
13 | for product in args:
14 | print(f'{random.choice(ACTIONS)} {product}')
15 | # print(f'Всё смешаем и заправим {sauce}')
16 | print(f'Всё смешаем и заправим {kwargs.get("sauce", "аджика")}')
17 | # get() - метод словаря, безопасно возвращающий значение по ключу ("sauce")
18 | # если ключ не найден, вернется значение по умолчанию ("аджика")
19 |
20 | cook('лук', 'картофель', 'помидоры', 'мясо', 'сыр', sauce='майонез')
21 | cook('лук', 'картофель', 'помидоры', 'мясо', 'сыр')
--------------------------------------------------------------------------------
/lesson12/guest_greeting.py:
--------------------------------------------------------------------------------
1 | # Приветствие гостей
2 |
3 | # Позиционные аргументы идут в *args
4 | # Именованные аргументы идут в *kwargs
5 | def greet(*args, **kwargs):
6 | # print(args) # кортеж
7 | # print(kwargs) # словарь
8 | for guest in args: # перебор элементов кортежа args
9 | print(f'Добро пожаловать, {guest}.')
10 | print(f'{kwargs["special"]}, для вас отдельный вход!')
11 | # получаем значение из kwargs по ключу именованного аргумента
12 |
13 |
14 | greet('Магомед', 'Патимат', special='Рамазан') # special - ключ, 'Рамазан' - значение
--------------------------------------------------------------------------------
/lesson12/high_order_funcs.py:
--------------------------------------------------------------------------------
1 | # Функции высшего порядка filter и map
2 |
3 | WORD_LIST = ['кошка', 'собака', 'попугай', 'крокодил'] # набор значений
4 |
5 | def len_less(word): # функция фильтрации
6 | return len(word) <= 6 # True если длина слова <= 6
7 |
8 | def add_text(word): # функция обработки элементов
9 | return "Животное " + word # Перед значением приписывается текст "Животное "
10 |
11 | # filter - фильтрует набор данных по опреленному правилу
12 | # Шаблон: filter(<функция фильтрации>, <набор данных>)
13 | # Отфильтруем список по словам с 6 буквами и меньше.
14 | res1 = list(filter(len_less, WORD_LIST))
15 | print(res1)
16 |
17 | # map - обрабатывает каждый элемент набора данных по какому-то правилу
18 | # Шаблон: map(<функция обработки>, <набор данных>)
19 | # Перед каждым словом поставим текст "Животное "
20 | res2 = list(map(add_text, WORD_LIST))
21 | print(res2)
22 |
23 |
24 | # lambda - однострочная анонимная функция
25 | # Шаблон: lambda <аргументы>: <возвращаемое значение>
26 | # Лямбда-функция, дублирующая функцию len_less
27 | print(list(filter(lambda x: len(x) <= 6, WORD_LIST)))
28 |
--------------------------------------------------------------------------------
/lesson12/recurs_factorial.py:
--------------------------------------------------------------------------------
1 | # Найдем факториал через рекурсию
2 | # x! = x * (x - 1) * (x - 2) * ... * 2 * 1
3 |
4 | def fact_func(n):
5 | if n == 1: # прерыватель рекурсии
6 | return 1
7 | return fact_func(n - 1) * n # Значение n берется из текущей области видимости функции
8 |
9 | # Сначала функция вызывает саму себя, "погружаясь" в вызовы внутри вызовов.
10 | # Дойдя до прерывателя рекурсии, исполнитель начнет всплывать,
11 | # Пока не дойдет до верхнего уровня
12 | print(fact_func(5))
--------------------------------------------------------------------------------
/lesson12/repeat.py:
--------------------------------------------------------------------------------
1 | # Именованные и позиционные аргументы, значения по умолчанию
2 |
3 | def mult_func(x=1, y=1): # значения по умолчанию
4 | return x * y
5 |
6 | print(mult_func()) # без аргументов
7 | print(mult_func(y=5, x=2)) # именованные аргументы
--------------------------------------------------------------------------------
/lesson13/data.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "id": 0,
4 | "fio": ["Амиров", "Саид"],
5 | "age": 32,
6 | "married": true
7 | },
8 | {
9 | "id": 1,
10 | "fio": ["Магомедов", "Магомед"],
11 | "age": 27,
12 | "married": false
13 | }
14 | ]
--------------------------------------------------------------------------------
/lesson13/films.json:
--------------------------------------------------------------------------------
1 | {
2 | "genres": [
3 | "ужас",
4 | "триллер",
5 | "комедия"
6 | ],
7 | "titles": [
8 | "It",
9 | "Пила",
10 | "Мачо и ботан"
11 | ]
12 | }
--------------------------------------------------------------------------------
/lesson13/json_funcs.py:
--------------------------------------------------------------------------------
1 | # Работа с json-файлами
2 |
3 | import json
4 |
5 | # Чтение с json-файла
6 | with open('lesson13/data.json', encoding='UTF-8') as json_file:
7 | json_info = json.load(json_file) # load выгружает и преобразует данные из json в Python-формат
8 |
9 | # С полученными данными можно работать как с обычной стуктурой Python
10 | print(json_info)
11 | print(json_info[0]['fio'])
12 | print(json_info[1])
13 |
14 | # Словарь с информацией о фильмах
15 | films_info = {
16 | 'genres': ['ужас', 'триллер', 'комедия'],
17 | 'titles': ['It', 'Пила', 'Мачо и ботан']
18 | }
19 |
20 | # Запись в json-файл
21 | with open('lesson13/films.json', 'w', encoding='UTF-8') as films_file:
22 | json.dump(films_info, films_file, ensure_ascii=False, indent=2)
23 | # dump - преобразует данные в json и загружает в файл
24 | # атрибут ensure_ascii нужен для отключения запрета на небезопасные символы типа кириллицы
25 | # indent - добавляет отступы и переносы в json
--------------------------------------------------------------------------------
/lesson13/repeat.py:
--------------------------------------------------------------------------------
1 | def simple_func(*args, **kwargs):
2 | print(args) # кортеж
3 | print(kwargs) # словарь
4 |
5 | # simple_func(1, 2, 3, x='qwerty', y='йцукен')
6 |
7 | num_list = [1, 2, 3, 4]
8 | print(list(filter(lambda x: x > 2, num_list))) # отфильтруем набор данных по условию
9 | print(list(map(lambda x: x ** 2, num_list))) # возведем все элементы списка в степень
--------------------------------------------------------------------------------
/lesson13/text_file.txt:
--------------------------------------------------------------------------------
1 | Один
2 | Два
3 | Три
4 | Четыре
5 |
--------------------------------------------------------------------------------
/lesson13/text_funcs.py:
--------------------------------------------------------------------------------
1 | # Работа с текстовыми файлами
2 |
3 | my_file = open('lesson13/text_file.txt', encoding='UTF-8') # устанавливаем соединение с файлом
4 |
5 | # full_text = my_file.read() # считывается весь текст
6 | # print(full_text)
7 |
8 | # part_text = my_file.read(30) # считать текст до 30-го символа
9 | # print(part_text)
10 |
11 | for line in my_file: # последовательно перебираем строки файла
12 | # print(line)
13 | # print(line, end='')
14 | print(line.rstrip('\n')) # удаляем переводы на новую строку в конце каждой строки
15 |
16 | my_file.close() # закрывает соединение с файлом
17 |
18 | # with - менеджер контекста
19 | with open('lesson13/text_file.txt', encoding='UTF-8') as my_file2:
20 | part_text = my_file2.read(30) # считать текст до 30-го символа
21 | print(part_text)
22 |
23 | # Для записи откроем с режимом "w" - write, запись с удалением прошлых данных
24 | with open('lesson13/text_file.txt', 'w', encoding='UTF-8') as my_file2:
25 | my_file2.write('Один\nДва\n')
26 |
27 | # Если файла нет, то он создастся
28 | # with open('lesson13/text_file1.txt', 'w', encoding='UTF-8') as my_file2:
29 | # my_file2.write('Один\nДва\n')
30 |
31 | # Для дозаписи откроем с режимом "a" - append, запись без удаления прошлых данных
32 | with open('lesson13/text_file.txt', 'a', encoding='UTF-8') as my_file2:
33 | my_file2.write('Три\nЧетыре\n')
34 |
--------------------------------------------------------------------------------
/lesson14/__pycache__/vars_and_funcs.cpython-311.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Intense-IT/Python2023/5dac21545e27bf3e8401915c962c8c5ca8770b68/lesson14/__pycache__/vars_and_funcs.cpython-311.pyc
--------------------------------------------------------------------------------
/lesson14/git_command.py:
--------------------------------------------------------------------------------
1 | print('Python 3')
2 |
3 | # git init # инициализация git
4 | # git config --global user.email my_address@mail.ru
5 | # git config --global user.name saeed
6 | # git add . # индексируем все файлы
7 | # git add <путь до индексируемого файла>
8 | # git reset <путь до файла> # удаление индексации файла
9 | # git status # уточнение статуса
10 | # git commit -m "Комментарий к коммиту"
11 | # git clone "путь до нужного удаленного репозитория"
12 | # git push # загружает все коммиты на удаленный репозиторий
13 | # git remote add origin https://github.com/Intense-IT/Python2023.git
14 | # Выше подключение к удаленному репозиторию
--------------------------------------------------------------------------------
/lesson14/modules.py:
--------------------------------------------------------------------------------
1 | # import vars_and_funcs # подключим наш файл как библиотеку
2 |
3 |
4 | # vars_and_funcs.my_func(20) # вызовем функцию my_func из файла vars_and_funcs.py
5 | # print(vars_and_funcs.my_num) # выведем значение my_num из файла vars_and_funcs.py
6 |
7 |
8 | from vars_and_funcs import my_func, my_num # точечно импортируем функции и переменные
9 |
10 | my_func(20) # используем без указания библиотеки
11 | print(my_num) # используем без указания библиотеки
12 |
--------------------------------------------------------------------------------
/lesson14/repeat.py:
--------------------------------------------------------------------------------
1 | import json
2 |
3 |
4 | with open('lesson14/text.txt', 'w', encoding='UTF-8') as my_file:
5 | my_file.write('Просто текст')
6 |
7 | student_score = {
8 | 'Magomed': 10,
9 | 'Мурад': 12
10 | }
11 | with open('lesson14/studs.json', 'w', encoding='UTF-8') as json_file:
12 | json.dump(student_score, json_file, ensure_ascii=False, indent=2)
--------------------------------------------------------------------------------
/lesson14/studs.json:
--------------------------------------------------------------------------------
1 | {
2 | "Magomed": 10,
3 | "Мурад": 12
4 | }
--------------------------------------------------------------------------------
/lesson14/text.txt:
--------------------------------------------------------------------------------
1 | Просто текст
--------------------------------------------------------------------------------
/lesson14/vars_and_funcs.py:
--------------------------------------------------------------------------------
1 | my_num = 10 # обычная переменная
2 |
3 | def my_func(num): # обычная функция
4 | print(num)
5 |
6 | def main(): # помещаем исполняемый код в отдельную функцию, чтоб изолировать область видимости
7 | my_func(55)
8 |
9 | # print(__name__) # хранит значение '__main__' либо название файла vars_and_func
10 | # в зависимости от контекста вызова
11 | if __name__ == '__main__':
12 | main() # вызываем функцию со всем исполняемым кодом
13 |
--------------------------------------------------------------------------------
/lesson15/classes.py:
--------------------------------------------------------------------------------
1 | # ООП - объектно-ориентированное программирование
2 | # Классы и объекты
3 | # Класс - тип данных
4 | # Объект - экземпляр класса
5 |
6 | # ПРОЦЕДУРНОЕ ПРОГРАММИРОВАНИЕ
7 | # def start_car():
8 | # global motor1, speed1, gasoline1
9 | # motor1 = True
10 | # speed1 = 50
11 | # gasoline1 -= 3
12 |
13 | # speed1 = 0
14 | # gasoline1 = 20
15 | # motor1 = False
16 |
17 | # start_car()
18 | # print(speed1, gasoline1, motor1)
19 |
20 |
21 | # ---------------------------------------
22 |
23 | # ПРОЦЕДУРНОЕ ПРОГРАММИРОВАНИЕ С АБСТРАКЦИЯМИ
24 | # Создаем общий метод
25 | # def start_car(car):
26 | # car['motor'] = True
27 | # car['speed'] = 50
28 | # car['gasoline'] -= car['spend']
29 |
30 |
31 | # # Создаем два автомобиля посредством словарей
32 | # car1 = {
33 | # 'speed': 0,
34 | # 'gasoline': 20,
35 | # 'motor': False,
36 | # 'color': 'white',
37 | # 'spend': 3
38 | # }
39 | # car2 = {
40 | # 'speed': 0,
41 | # 'gasoline': 40,
42 | # 'motor': False,
43 | # 'color': 'red',
44 | # 'spend': 5
45 | # }
46 |
47 |
48 | # # Вызываем метод для каждого словаря
49 | # start_car(car1)
50 | # start_car(car2)
51 | # print(car1)
52 | # print(car2)
53 |
54 |
55 | # ---------------------------------------
56 |
57 | # ОБЪЕКТНО-ОРИЕНТИРОВАННОЕ ПРОГРАММИРОВАНИЕ
58 | class Car: # class - зарезервированное слово, Car - имя класса
59 | speed = 0 # свойство/атрибут класса Car
60 | gasoline = 20
61 | motor = False
62 | color = 'white'
63 | spend = 3
64 |
65 | def start_car(self): # метод класса Car
66 | # self хранит ссылку на конкретный объект, у которого вызываются методы
67 | # и изменяются свойства
68 | self.motor = True
69 | self.speed = 50
70 | self.gasoline -= self.spend
71 | print('Ррррр')
72 |
73 | def gasoline_info(self): # метод класса Car
74 | print(f'В баке осталось {self.gasoline} литров')
75 |
76 |
77 | car1 = Car() # создаем экземпляр класса Car
78 | car1.gasoline_info() # вызываем метод проверки уровня бензина
79 | car1.start_car() # заводим авто
80 | car1.gasoline_info()
81 | print(car1.gasoline)
82 | print(car1)
83 | car2 = Car()
84 | print(car2.gasoline) # свойства car2 не зависят от car1
85 | # объекту можно добавить новое свойство
86 | car2.breaks = 'сдулось колесо'
87 | print(car2.breaks)
88 |
--------------------------------------------------------------------------------
/lesson15/classes2.py:
--------------------------------------------------------------------------------
1 | # Создание объектов с уникальными значениями атрибутов
2 |
3 |
4 | # type() позволяет узнать тип данных объекта
5 | # print(type(1))
6 | # print(type(1.5))
7 | # print(type('asdf'))
8 | # print(type([]))
9 | # print(type(lambda x: x))
10 |
11 |
12 | class Car:
13 | # магический метод __init__, вызываемый автоматически
14 | # в момент создания объекта - позволяет задавать значения
15 | # свойста в момент создания
16 | def __init__(self, color, gasoline, spend=3):
17 | self.speed = 0
18 | self.gasoline = gasoline
19 | self.motor = False
20 | self.color = color
21 | self.spend = spend
22 |
23 | def start_car(self): # метод класса
24 | self.motor = True
25 | self.speed = 50
26 | self.gasoline -= self.spend
27 | print('Ррррр')
28 |
29 | def gasoline_info(self): # метод класса
30 | print(f'В баке осталось {self.gasoline} литров')
31 |
32 |
33 | # Создаем три объекта - экземпляра класса Car
34 | car1 = Car('white', 30, 5) # позиционные аргументы
35 | car2 = Car('red', 40)
36 | car3 = Car(spend=7, color='blue', gasoline=45) # именованные аргументы
37 |
38 | # Свойства каждого объекта привязаны только к самому объекту
39 | print(car1.color, car1.gasoline, car1.spend)
40 | print(car2.color, car2.gasoline, car2.spend)
41 | print(car3.color, car3.gasoline, car3.spend)
42 |
43 | # Но все они относятся к одному классу
44 | print(type(car1))
45 | print(type(car2))
46 | print(type(car3))
47 |
--------------------------------------------------------------------------------
/lesson15/decorators.py:
--------------------------------------------------------------------------------
1 | # Декораторы - инструмент, позволяющий расширять возможности
2 | # функции без изменений ее исходного кода
3 |
4 |
5 | # Структура декоратора
6 | # def <имя декоратора>(<имя переменной, хранящей исходную ф-ю>)
7 | # def <имя убертки для функции>(*args, **kwargs):
8 | # Блок кода с вызовом исходной функции и др. возможностями
9 | # return <имя обертку>
10 |
11 |
12 | # Декоратор 1, добавляющий в конец результата "."
13 | def add_mark(func):
14 | def wrapper(*args, **kwargs):
15 | result = func(*args, **kwargs)
16 | return result + '.'
17 | return wrapper
18 |
19 |
20 | # Декоратор 2, выводящий в консоль информацию о функции
21 | def func_info(func):
22 | def wrapper(*args, **kwargs):
23 | print(f'Название функции: {func.__name__}')
24 | print(f'Позиционные аргументы: {args}')
25 | print(f'Именованные аргументы: {kwargs}')
26 | result = func(*args, **kwargs)
27 | print(f'Результат выполнения функции: {result}')
28 | return result
29 | return wrapper
30 |
31 |
32 | # функция приветствия, которую расширили декоратором add_mark
33 | @add_mark
34 | def greeting(name):
35 | return f'Hello, {name}'
36 |
37 |
38 | # ф-ия диалога, расширенная декоратором func_info
39 | @func_info
40 | def dialogue(name):
41 | return f'How are you, {name}'
42 |
43 |
44 | # ф-ия прощания, расширенная декораторами func_info и add_mark
45 | @func_info
46 | @add_mark
47 | def goodbye(name):
48 | return f'Goodbye, {name}'
49 |
50 |
51 | print(greeting('Саид'))
52 | print(dialogue('Магомед'))
53 | print(goodbye('Патимат'))
54 |
55 | # декоратором создается новая ф-ия, которая сохраняется
56 | # в переменную new_greeting
57 | new_greeting = func_info(greeting)
58 | new_greeting('Заур')
59 |
--------------------------------------------------------------------------------
/lesson16/encapsulation.py:
--------------------------------------------------------------------------------
1 | # Инкапсуляция - принцип ООП, сокрытие данных,
2 | # подразумевающий ограничение прямого доступа к данным.
3 |
4 | # Базовые понятия: геттер (getter) и сеттер (setter) -
5 | # позволяют настраивать доступ, считывание и запись, к данным
6 |
7 | class Bank_account:
8 | def __init__(self, name, money):
9 | self.name = name
10 | # свойство __money, хранящее количество денег, скрыто
11 | self.__money = money
12 |
13 | # Создадим общедоступное свойство public_money
14 |
15 | # реализуем геттер к public_money через @property
16 | @property
17 | def public_money(self):
18 | check = input('Введите пароль: ')
19 | if check == '1234':
20 | return self.__money
21 | else:
22 | return 'У вас нет доступа к данной информации.'
23 |
24 | # реализуем сеттер к public_money через @public_money.setter
25 | @public_money.setter
26 | def public_money(self, value):
27 | if isinstance(value, int):
28 | self.__money = value
29 | else:
30 | print('У вас ошибка в данных')
31 |
32 |
33 | # создаем экземпляр класса Bank_account
34 | me = Bank_account('Саид', 1000)
35 |
36 | # print(me.__money) # выдаст ошибку
37 | print(me.public_money)
38 | me.public_money = 'qwer'
39 | print(me.public_money)
40 |
--------------------------------------------------------------------------------
/lesson16/repeat.py:
--------------------------------------------------------------------------------
1 | # Класс - тип данных
2 | # Объект - экземпляр класса
3 |
4 | class Car:
5 | # __init__() - магический метод, конструктор класса
6 | def __init__(self, wheels): # self хранит ссылку на объект
7 | self.wheels = wheels # свойство/атрибут класса
8 |
9 | def ride(self): # метод класса Car
10 | print('Вррррр')
11 |
12 |
13 | my_car = Car(3) # экземпляр класса Car
14 | print(my_car) # выводим сам объект
15 | print(my_car.wheels) # выводим значение свойства wheels объекта my_car
16 | my_car.ride() # вызываем метод ride класса Car к объекту my_car
17 |
--------------------------------------------------------------------------------
/lesson16/ride.py:
--------------------------------------------------------------------------------
1 | # Игра Гонки
2 | # Реализуем двумя путями - через словари и функции и через ООП
3 |
4 | from time import sleep
5 |
6 |
7 | # гоночная трасса
8 | RACE_TRACK = 50
9 |
10 |
11 | # # функция обычной езды
12 | # def drive(car):
13 | # car['distance'] += car['speed']
14 | # car['tank'] -= car['spend']
15 |
16 |
17 | # # функция включения нитро
18 | # def push_nitro(car):
19 | # car['distance'] += car['speed'] + car['nitro']
20 | # car['tank'] -= car['spend'] + car['nitro'] * 1.5
21 |
22 |
23 | # # функция вывода информации о гонщике
24 | # def racer_info(car):
25 | # print(f'{car["name"]} проехал {car["distance"]} из {RACE_TRACK}.')
26 | # print(f'Осталось {car["tank"]} литров топлива.\n')
27 |
28 |
29 | # # функция выбора игроком действия
30 | # def action(car):
31 | # your_choice = input(
32 | # f'{car["name"]}, выберите действие:\n'
33 | # '1 - обычная езда,\n'
34 | # '2 - включить нитро.\n'
35 | # 'Ваш выбор: '
36 | # )
37 | # if your_choice == 1:
38 | # drive(car)
39 | # racer_info(car)
40 | # else:
41 | # push_nitro(car)
42 | # racer_info(car)
43 |
44 |
45 | # # игрок 1
46 | # car1 = {
47 | # 'name': 'Магомед',
48 | # 'speed': 8,
49 | # 'spend': 4,
50 | # 'tank': 40,
51 | # 'nitro': 4,
52 | # 'distance': 0
53 | # }
54 |
55 | # # игрок 2
56 | # car2 = {
57 | # 'name': 'Патимат',
58 | # 'speed': 7,
59 | # 'spend': 3,
60 | # 'tank': 35,
61 | # 'nitro': 5,
62 | # 'distance': 0
63 | # }
64 |
65 |
66 | # весь игровой процесс
67 | # while True:
68 | # action(car1)
69 | # sleep(2)
70 | # action(car2)
71 | # sleep(3)
72 |
73 |
74 | # Класс авто
75 | class Car:
76 | # конструктор класса Car
77 | def __init__(self, name, speed, spend, tank, nitro, distance):
78 | self.name = name
79 | self.speed = speed
80 | self.spend = spend
81 | self.tank = tank
82 | self.nitro = nitro
83 | self.distance = distance
84 |
85 | # метод обычной езды класса Car
86 | def drive(self):
87 | # этот код
88 | self.distance += self.speed # изменяем значение свойства объекта
89 | self.tank -= self.spend
90 | # вместо строчек ниже
91 | # car['distance'] += car['speed']
92 | # car['tank'] -= car['spend']
93 |
94 | # метод включения нитро
95 | def push_nitro(self):
96 | self.distance += self.speed + self.nitro
97 | self.tank -= self.spend + self.nitro * 1.5
98 |
99 | # метод вывода информации о гонщике
100 | def racer_info(self):
101 | print(f'{self.name} проехал {self.distance} из {RACE_TRACK}.')
102 | print(f'Осталось {self.tank} литров топлива.\n')
103 |
104 | # метод выбора игроком действия
105 | def action(self):
106 | your_choice = input(
107 | f'{self.name}, выберите действие:\n'
108 | '1 - обычная езда,\n'
109 | '2 - включить нитро.\n'
110 | 'Ваш выбор: '
111 | )
112 | if your_choice == 1:
113 | self.drive()
114 | self.racer_info()
115 | else:
116 | self.push_nitro()
117 | self.racer_info()
118 |
119 | # метод проверки на победу и проигрыш
120 | def win_or_lose(self):
121 | if self.distance >= RACE_TRACK:
122 | print(f'{self.name} победил!')
123 | return True
124 | elif self.tank <= 0:
125 | print(f'{self.name} проиграл!')
126 | return True
127 | return False
128 |
129 |
130 | # вся исполняемая часть кода обернута в ф-ию main()
131 | def main():
132 | car1 = Car('Магомед', 8, 4, 45, 4, 0)
133 | car2 = Car('Патимат', 7, 3, 40, 5, 0)
134 |
135 | while True:
136 | car1.action()
137 | sleep(2)
138 | car2.action()
139 | sleep(2)
140 | if car1.win_or_lose() or car2.win_or_lose():
141 | break
142 |
143 |
144 | # ф-ия main выполняется только если это исполняемый файл
145 | if __name__ == '__main__':
146 | main()
147 |
--------------------------------------------------------------------------------
/lesson17/inheritance.py:
--------------------------------------------------------------------------------
1 | # Наследование - принцип ООП
2 |
3 | # Класс Animal
4 | class Animal:
5 | def __init__(self, nickname):
6 | self.nickname = nickname
7 | self.paws = 4
8 |
9 | def run(self):
10 | print('Побежала!')
11 |
12 | def sound(self):
13 | print('Визг!')
14 |
15 |
16 | # Класс Cat, дочерний классу Animal
17 | class Cat(Animal):
18 | def sound(self): # перезапись метода sound()
19 | print('Мяу')
20 |
21 |
22 | # Класс Dog, дочерний классу Animal
23 | class Dog(Animal):
24 | def sound(self):
25 | print('Гав-гав!')
26 |
27 | # новый метод
28 | def bite(self):
29 | print('УКУСИЛА!')
30 |
31 |
32 | # Класс Shepherd, дочерний классу Dog
33 | class Shepherd(Dog):
34 | # Метод __init__() перезаписывается
35 | def __init__(self, nickname, ancestry):
36 | # super() говорит, что брать метод (__init__) надо у родителя
37 | super().__init__(nickname)
38 | # строчка выше заменяет задание self.nickname и self.paws
39 | self.ancestry = ancestry
40 |
41 | def sound(self):
42 | print('Ррррав!')
43 |
44 | def bite(self):
45 | super().bite() # вызывается метод bite родительского класса
46 | print('Гонит овец к стаду.') # доп. действия
47 |
48 |
49 | # Создаем экземпляр класса Cat
50 | cat = Cat('Пушок')
51 | cat.run() # метод run достался от Animal без изменений
52 | cat.sound() # метод sound у объекта от класса Cat
53 |
54 | # Создаем экземпляр класса Dog
55 | dog = Dog('Барбос')
56 | dog.run() # метод run достался от Animal без изменений
57 | dog.sound() # метод sound у объекта от класса Dog
58 | dog.bite() # метод bite у объекта от класса Dog
59 |
60 | # Создаем экземпляр класса Shepherd
61 | shepherd_dog = Shepherd('Тузик', 'чистокровный')
62 | shepherd_dog.run() # метод run достался от Animal без изменений
63 | shepherd_dog.sound() # метод sound у объекта от класса Shepherd
64 | shepherd_dog.bite() # метод bite у объекта от класса Shepherd
65 |
--------------------------------------------------------------------------------
/lesson17/magic_methods.py:
--------------------------------------------------------------------------------
1 | # Магические методы
2 |
3 | # Магический метод __init__ вызывается при создании экземпляра класса
4 |
5 | # Магические методы __str__ и __repr__
6 |
7 | class Cat():
8 | def __init__(self, name):
9 | self.name = name
10 | self.age = 3
11 | self.weight = 10
12 |
13 | # __str__ - магический метод, отвечающий за отображение информации,
14 | # хранимой в объекте, при выводе пользователю
15 | def __str__(self):
16 | return f'Это кошка по имени {self.name}, весящая {self.weight} кг!'
17 | # Возвращаемая информация только строкового типа
18 |
19 | # __repr__ - магический метод, отвечающий за отображение информации,
20 | # хранимой в объекте, при передаче другим стурктурам.
21 | def __repr__(self):
22 | return {
23 | 'name': self.name,
24 | 'age': self.age,
25 | 'weight': self.weight
26 | }
27 | # Возвращаемая информация может быть любого типа
28 |
29 |
30 | # Создаем экземпляр класса Cat
31 | my_cat = Cat('Снежок')
32 | # Вызовем метод __str__() у объекта my_cat командой print
33 | print(my_cat)
34 | # Вызовем метод __repr__() у объекта my_cat
35 | print(my_cat.__repr__())
36 |
37 |
38 | class Bank_account:
39 | def __init__(self, name, money):
40 | self.name = name
41 | self.money = money
42 |
43 | # Переопределим магический метод __str__
44 | def __str__(self):
45 | return f'На счету {self.name} - {self.money}$'
46 |
47 | # Магические методы для операций сравнения
48 | # __eq__(self, other) - магический метод для операции " == "
49 | # __ne__(self, other) - магический метод для операции " != "
50 | # __lt__(self, other) - магический метод для операции " < "
51 | # __gt__(self, other) - магический метод для операции " > "
52 | # __le__(self, other) - магический метод для операции " <= "
53 | # __ge__(self, other) - магический метод для операции " >= "
54 |
55 | # Для операции x > y вызов метода выглядит так: x.__gt__(y)
56 | def __gt__(self, other):
57 | # сравниваем не объекты, а их свойства money
58 | return self.money > other.money
59 |
60 | # Магические методы для арифметических операций
61 | # __add__(self, other) - магический метод для операции сложения " + "
62 | # __sub__(self, other) - магический метод для операции вычитания " - "
63 | # __mul__(self, other) - магический метод для операции умножения " * "
64 | # __div__(self, other) - магический метод для операции деления " / "
65 | # __floordiv__(self, other) - магический метод для операции
66 | # целочисленного деления " // "
67 |
68 | # Для операции x + y вызов метода выглядит так: x.__add__(y)
69 | def __add__(self, other):
70 | return self.money + other.money
71 | # При желании можно менять значения свойств и вызывать методы
72 | # self.money = self.money + other.money
73 | # other.money = 0
74 | # return self.money
75 |
76 |
77 | # Создаем экземпляр класса Bank_account
78 | my_account = Bank_account('Саид', 10000)
79 | # При выводе значения объекта сработает магический метод __str__
80 | print(my_account)
81 |
82 | neighbor_acc = Bank_account('Магомед', 5000)
83 |
84 | # При сравнении объектов сработает магический метод __gt__
85 | if my_account > neighbor_acc:
86 | print('Я победил!')
87 | else:
88 | print('Победил сосед ;(')
89 |
90 | # При сложении объектов сработает магический метод __add__
91 | print(my_account + neighbor_acc)
92 |
--------------------------------------------------------------------------------
/lesson17/polymorphism.py:
--------------------------------------------------------------------------------
1 | # Полиморфизм - принцип ООП
2 |
3 | # Класс для создания самолетов
4 | class Airplane:
5 | weight = 1000000
6 |
7 | def fly(self): # метод полета самолета
8 | print('Турбины крутятся жж-ж-ж-жж!')
9 |
10 |
11 | # Класс для создания птиц
12 | class Bird:
13 | def fly(self): # метод полета птицы
14 | print('Птица машет крыльями.')
15 |
16 | def bird_fly(self): # этот метод незнаком ф-ии start_fly()
17 | print('Птица машет крыльями.')
18 |
19 |
20 | # Ф-ия старта полета
21 | def start_fly(obj):
22 | obj.fly()
23 |
24 |
25 | # Создаем объекты по классам
26 | plane = Airplane()
27 | pigeon = Bird()
28 |
29 | # вызываем метод start_fly с разными типами объектов без каких-либо ошибок
30 | start_fly(plane)
31 | start_fly(pigeon)
32 |
--------------------------------------------------------------------------------
/lesson18/databases.py:
--------------------------------------------------------------------------------
1 | # База данных - это набор информации, организованно хранящийся
2 | # в электронном виде.
3 |
4 | # Реляционная база данных - база данных,
5 | # основанная на реляционной модели данных
6 | # («реляционный» подразумевает математическое понятие «отношение»,
7 | # «relation» - взаимосвязь различных объектов).
8 |
9 | # СУБД (система управления базами данных) - комплекс программ,
10 | # позволяющих управлять базой данных, ее таблицами и
11 | # манипулировать хранящимися в них данными.
12 |
13 | # SQL (Structured Query Language) - декларативный язык программирования,
14 | # применяемый для управления данными в реляционной базе данных.
15 |
16 | # Библиотека для SQLite является базовой в Python
17 | import sqlite3
18 |
19 |
20 | con = sqlite3.connect('lesson18/new.db') # подключаемся к БД
21 | cursor = con.cursor() # создаем курсор/каретка/бегунок
22 |
23 |
24 | # Команда DROP TABLE удаляет таблицу
25 | cursor.execute('''
26 | DROP TABLE books;
27 | ''')
28 |
29 | # execute() - метод, выполняющий SQL-запросы.
30 | # Этому методы передается SQL-запрос в виде многострочного объекта.
31 | cursor.execute('''
32 | -- Двойное тире это знак однострочного комментария в SQL
33 |
34 | -- CREATE TABLE books (
35 | -- Команда CREATE TABLE IF NOT EXISTS создает таблицу,
36 | -- только если ее до этого не существовало
37 |
38 | CREATE TABLE IF NOT EXISTS books (
39 | -- UNIQUE говорит, что поле должно быть уникальным
40 | -- id INTEGER UNIQUE,
41 | -- PRIMARY KEY говорит, что данное поле - первичный ключ
42 | -- AUTOINCREMENT - значение выдается автоматом, увеличивая предыдущее на 1
43 |
44 | id INTEGER PRIMARY KEY AUTOINCREMENT,
45 | title VARCHAR(255),
46 | author VARCHAR(50),
47 | year INTEGER(5)
48 | );
49 | ''')
50 |
51 | # Добавим в таблицу books запись
52 | cursor.execute('''
53 | -- Команда INSERT INTO вставляет запись в указанную таблицу
54 | INSERT INTO books VALUES (
55 | 1,
56 | 'Оно',
57 | 'Стивен Кинг',
58 | 1986
59 | );
60 | ''')
61 |
62 | # Добавим запись с полями title, author, year, т.е. без id,
63 | # т.к. id выдается автоматически
64 | cursor.execute('''
65 | INSERT INTO books(title, author, year) VALUES (
66 | 'Бойцовский клуб',
67 | 'Чак Паланик',
68 | 1996
69 | );
70 | ''')
71 |
72 | # Добавим запись без поля year.
73 | # В качестве значения в ячейку запишется null
74 | cursor.execute('''
75 | INSERT INTO books(title, author) VALUES (
76 | 'Крестный отец',
77 | 'Марио Пьюзо'
78 | );
79 | ''')
80 |
81 | # Неэффективный путь добавления данных в запрос
82 | # Данные для SQL-запроса
83 | # query_data = ('Собачье сердце', 'Михаил Булгаков', 1925)
84 | # full_query = f'''
85 | # INSERT INTO books(title, author, year) VALUES (
86 | # '{query_data[0]}',
87 | # '{query_data[1]}',
88 | # {query_data[2]}
89 | # );
90 | # '''
91 | # cursor.execute(full_query)
92 |
93 | # Ниже более эффективный путь добавления данных в запрос
94 | # query_data = ('Собачье сердце', 'Михаил Булгаков', 1925)
95 | # cursor.execute(
96 | # '''INSERT INTO books(title, author, year) VALUES(?, ?, ?)''',
97 | # query_data)
98 |
99 | # Самый эффективный путь добавления данных в запрос.
100 | # Сам запрос и данные вынесены в отдельные переменные.
101 | query_data = ('Собачье сердце', 'Михаил Булгаков', 1925)
102 | query = '''INSERT INTO books(title, author, year) VALUES(?, ?, ?)'''
103 | cursor.execute(query, query_data)
104 |
105 | con.commit() # подтверждаем все изменения, внесенные в БД
106 | cursor.close() # закрываем курсор
107 | con.close() # закрываем соединение с БД
108 |
--------------------------------------------------------------------------------
/lesson18/new.db:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Intense-IT/Python2023/5dac21545e27bf3e8401915c962c8c5ca8770b68/lesson18/new.db
--------------------------------------------------------------------------------
/lesson19/databases2.py:
--------------------------------------------------------------------------------
1 | # Рассматриваем считывание данных из таблицы БД
2 | import sqlite3
3 |
4 |
5 | # Создаем соединение с БД и курсор
6 | con = sqlite3.connect('lesson19/second_db.db')
7 | cursor = con.cursor()
8 |
9 |
10 | # Создаем таблицу books
11 | cursor.execute("""
12 | CREATE TABLE IF NOT EXISTS books(
13 | id INTEGER PRIMARY KEY AUTOINCREMENT,
14 | title VARCHAR(200),
15 | author VARCHAR(60),
16 | year INTEGER(5)
17 | );
18 | """)
19 |
20 | # Добавим 5 записей в таблицу через команду executemany
21 | query = """
22 | INSERT INTO books(title, author, year) VALUES (?, ?, ?);
23 | """
24 | books_list = [
25 | ('Властелин колец', 'Джон Толкин', 1949),
26 | ('Зеленая миля', 'Стивен Кинг', 1996),
27 | ('Финансист', 'Теодор Драйзер', 1912),
28 | ('Титан', 'Теодор Драйзер', 1914),
29 | ('Стоик', 'Теодор Драйзер', 1945)
30 | ]
31 | # cursor.executemany(query, books_list)
32 |
33 | # Считывание данных из таблицы
34 | # Для этого применяется конструкция SELECT ... FROM ...
35 | cursor.execute("""SELECT * FROM books""")
36 | cursor.execute("""SELECT title FROM books""")
37 | cursor.execute("""SELECT title, year FROM books""")
38 | # Можно прописывать условия проверки
39 | cursor.execute("""SELECT title, year FROM books WHERE year < 1940""")
40 | cursor.execute("""SELECT title, year FROM books WHERE year = 1945""")
41 | # Можно применять логические операторы OR, AND, NOT
42 | cursor.execute("""
43 | SELECT title, year
44 | FROM books
45 | WHERE year > 1930 AND year < 1950 ORDER BY year DESC LIMIT 1
46 | """)
47 | # BETWEEN ... AND ... - команда проверки вхождения в интервал
48 | cursor.execute("""
49 | SELECT title, year
50 | FROM books
51 | WHERE year BETWEEN 1930 AND 1950
52 | """)
53 | # IN позволяет проверить вхождение значения в список
54 | cursor.execute("""
55 | SELECT title, year
56 | FROM books
57 | WHERE author IN ('Чак Паланик', 'Теодор Драйзер', 'Виктор Пелевин')
58 | """)
59 | # Команда LIKE принимает шаблон строки
60 | # со знаками % (ноль, один или неск. символов) и _ (один символ)
61 | cursor.execute("""
62 | SELECT title, year
63 | FROM books
64 | WHERE title LIKE '% колец'
65 | """)
66 |
67 | # Команда fetchall() возвращает данные из курсора
68 | # print(cursor.fetchall())
69 |
70 | # По курсору можно пройтись как по итератору циклом
71 | # for row in cursor:
72 | # print(row)
73 |
74 | # GROUP BY позволяет сгруппировать записи по полям
75 | # Можно вызывать функции SQL для группы данных: MIN, MAX, AVG, SUM, COUNT
76 | cursor.execute("""
77 | SELECT author, COUNT()
78 | FROM books
79 | GROUP BY author
80 | """)
81 | print(cursor.fetchall())
82 |
83 |
84 | # Изменение данных командой UPDATE ... SET ... WHERE ...
85 | cursor.execute("""
86 | UPDATE books
87 | SET author = 'С. Кинг'
88 | WHERE author = 'Стивен Кинг'
89 | """)
90 |
91 |
92 | # Удаление данных командой DELETE ... WHERE ...
93 | cursor.execute("""
94 | DELETE FROM books
95 | WHERE author = 'С. Кинг'
96 | """)
97 |
98 | # Посмотрим результат
99 | cursor.execute("""SELECT * FROM books""")
100 | print(cursor.fetchall())
101 |
102 | con.commit()
103 | cursor.close()
104 | con.close()
105 |
--------------------------------------------------------------------------------
/lesson19/first_db.db:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Intense-IT/Python2023/5dac21545e27bf3e8401915c962c8c5ca8770b68/lesson19/first_db.db
--------------------------------------------------------------------------------
/lesson19/repeat.py:
--------------------------------------------------------------------------------
1 | import sqlite3
2 |
3 |
4 | # создаем соединение с БД и курсор
5 | con = sqlite3.connect('lesson19/first_db.db')
6 | cursor = con.cursor()
7 |
8 |
9 | # создаем таблицу books
10 | cursor.execute("""
11 | CREATE TABLE IF NOT EXISTS books(
12 | id INTEGER PRIMARY KEY AUTOINCREMENT,
13 | title VARCHAR(200),
14 | author VARCHAR(60),
15 | year INTEGER(5)
16 | );
17 | """)
18 |
19 | # Добавляем запись в таблицу books
20 |
21 | # Неэффективый способ добавления записи
22 | # cursor.execute("""
23 | # INSERT INTO books(title, author, year) VALUES (
24 | # 'Маленький принц',
25 | # 'Антуан Экзюпери',
26 | # 1942
27 | # );
28 | # """)
29 |
30 | # Эффективный способ добавления записи
31 | # Текст запроса и данные вынесены в отдельные переменные
32 | query = """
33 | INSERT INTO books(title, author, year) VALUES (?, ?, ?)
34 | """
35 | query_data = ('Маленький принц', 'Антуан Экзюпери', 1942)
36 | cursor.execute(query, query_data)
37 |
38 |
39 | # Подтверждаем изменения, закрываем курсор и подключение к БД
40 | con.commit()
41 | cursor.close()
42 | con.close()
43 |
--------------------------------------------------------------------------------
/lesson19/second_db.db:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Intense-IT/Python2023/5dac21545e27bf3e8401915c962c8c5ca8770b68/lesson19/second_db.db
--------------------------------------------------------------------------------
/lesson2/input_func.py:
--------------------------------------------------------------------------------
1 | your_name = input("Введите ваше имя: ")
2 | print("Ваше имя: " + your_name)
--------------------------------------------------------------------------------
/lesson2/repeat.py:
--------------------------------------------------------------------------------
1 | print(20)
2 | print("Меня зовут " + "Саид")
3 | print("Меня зовут", "Саид", 10 + 5)
--------------------------------------------------------------------------------
/lesson2/shortcuts.py:
--------------------------------------------------------------------------------
1 | number = 20
2 | number = number + 5
3 | number += 5 # сокращенная запись строки 2
4 | number -= 3
5 | number *= 4
6 | # number /= 3 # обычное деление
7 | number //= 3 # целочисленное деление
8 | print(number)
--------------------------------------------------------------------------------
/lesson2/simple_types.py:
--------------------------------------------------------------------------------
1 | print(15) # число
2 | print(3.93) # число с плавающей запятой
3 | print("Просто текст") # строка
4 | print(True, False) # логический тип
--------------------------------------------------------------------------------
/lesson2/tran_types.py:
--------------------------------------------------------------------------------
1 | number1 = 20
2 | number2 = "3.5"
3 | # print(number1 + number2) # даст ошибку
4 | print(str(number1) + number2) # str() int -> str
5 | # print(number1 + int(number2)) # int() str -/> int, даст ошибку
6 | print(number1 + float(number2)) # float() str -> float
7 | print(int(3.5)) # преобразование float -> int
--------------------------------------------------------------------------------
/lesson2/variables.py:
--------------------------------------------------------------------------------
1 | my_number1 = 20
2 | print(my_number1) # 20
3 | another_variable = my_number1
4 | my_number1 = 10
5 | print(another_variable) # 20
6 | my_number1 = "Саид"
7 | print(my_number1) # 'Саид'
--------------------------------------------------------------------------------
/lesson20/db_first.db:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Intense-IT/Python2023/5dac21545e27bf3e8401915c962c8c5ca8770b68/lesson20/db_first.db
--------------------------------------------------------------------------------
/lesson20/db_second.db:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Intense-IT/Python2023/5dac21545e27bf3e8401915c962c8c5ca8770b68/lesson20/db_second.db
--------------------------------------------------------------------------------
/lesson20/db_third.db:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Intense-IT/Python2023/5dac21545e27bf3e8401915c962c8c5ca8770b68/lesson20/db_third.db
--------------------------------------------------------------------------------
/lesson20/repeat.py:
--------------------------------------------------------------------------------
1 | import sqlite3
2 |
3 |
4 | con = sqlite3.connect('lesson20/db_first.db')
5 | cursor = con.cursor()
6 |
7 |
8 | # Создание таблицы
9 | cursor.execute("""
10 | CREATE TABLE IF NOT EXISTS books(
11 | id INTEGER PRIMARY KEY AUTOINCREMENT,
12 | title VARCHAR(200),
13 | author VARCHAR(60),
14 | year INTEGER(5)
15 | );
16 | """)
17 |
18 | # Чтение записей
19 | cursor.execute("SELECT * FROM books")
20 | # Вывод данных из курсора в консоль
21 | print(cursor.fetchall())
22 |
23 | # Добавление записи
24 | query = "INSERT INTO books(title, author, year) VALUES (?, ?, ?)"
25 | query_data = ('Война и мир', 'Лев Толстой', 1950)
26 | cursor.execute(query, query_data)
27 |
28 | # Изменение записей
29 | cursor.execute("""
30 | UPDATE books
31 | SET year = 1869
32 | WHERE title = 'Война и мир'
33 | """)
34 |
35 | cursor.execute("SELECT * FROM books")
36 | print(cursor.fetchall())
37 |
38 | # Удаление записей
39 | cursor.execute("DELETE FROM books WHERE title = 'Война и мир'")
40 |
41 |
42 | con.commit()
43 | cursor.close()
44 | con.close()
45 |
--------------------------------------------------------------------------------
/lesson20/sql_join.py:
--------------------------------------------------------------------------------
1 | # JOIN - команда для объединения нескольких групп данных
2 | # из разных таблиц
3 | import sqlite3
4 |
5 |
6 | con = sqlite3.connect('lesson20/db_third.db')
7 | cursor = con.cursor()
8 |
9 |
10 | # Предварительно удаляем таблицы, чтоб записи не накапливались
11 | # в них
12 | cursor.execute("DROP TABLE books")
13 | cursor.execute("DROP TABLE authors")
14 |
15 | # Создаем таблицу книг
16 | cursor.execute("""
17 | CREATE TABLE IF NOT EXISTS books(
18 | id INTEGER PRIMARY KEY AUTOINCREMENT,
19 | title VARCHAR(200),
20 | author_id INTEGER,
21 | year INTEGER(5),
22 | FOREIGN KEY(author_id) REFERENCES authors(id)
23 | );
24 | """)
25 |
26 | # Создаем таблицу авторов
27 | cursor.execute("""
28 | CREATE TABLE IF NOT EXISTS authors(
29 | id INTEGER PRIMARY KEY AUTOINCREMENT,
30 | name VARCHAR(60)
31 | );
32 | """)
33 |
34 | # Добавление нескольких записей в таблицу authors
35 | author_query = "INSERT INTO authors(name) VALUES(?)"
36 | author_data = [
37 | ('Лев Толстой',),
38 | ('Пушкин А. С.',),
39 | ('Берроуз',)
40 | ]
41 | cursor.executemany(author_query, author_data)
42 |
43 | # Добавление нескольких записей в таблицу books
44 | books_query = """
45 | INSERT INTO books(title, author_id, year)
46 | VALUES(?, ?, ?)
47 | """
48 | books_data = [
49 | ('Война и мир', 1, 1950),
50 | ('Джанки', 3, 1997),
51 | ('Анна Каренина', 1, 1877),
52 | ('Колобок', None, 1000)
53 | ]
54 | cursor.executemany(books_query, books_data)
55 |
56 |
57 | # Получим связанный набор данных из нескольких таблиц
58 |
59 | # Этот способ просто перебирает все комбинации записей двух таблиц
60 | # cursor.execute("""
61 | # SELECT *
62 | # FROM books, authors
63 | # """)
64 |
65 | # Этот способ отсеивает данные двух таблиц, не связанные между собой
66 | cursor.execute("""
67 | SELECT *
68 | FROM books, authors
69 | WHERE books.author_id = authors.id;
70 | """)
71 |
72 | # Способ ниже работает таких же образом, однако является
73 | # рекомендованным для подобных задач
74 | # INNER JOIN - в итоговый набор попадают только записи,
75 | # соответствующие условию
76 | cursor.execute("""
77 | SELECT *
78 | FROM books
79 | INNER JOIN authors ON books.author_id = authors.id
80 | """)
81 |
82 | # LEFT JOIN - в итоговый набор попадают все записи первой таблицы,
83 | # даже те, которым нет соответствующего значения во второй таблице.
84 | # Отсутствующие значения второй таблицы заменяются на null/None.
85 | cursor.execute("""
86 | SELECT *
87 | FROM books
88 | LEFT JOIN authors ON books.author_id = authors.id
89 | """)
90 |
91 | # RIGHT JOIN - работает аналогично LEFT JOIN, но за основу берется
92 | # правая, вторая таблица.
93 | cursor.execute("""
94 | SELECT *
95 | FROM books
96 | RIGHT JOIN authors ON books.author_id = authors.id
97 | """)
98 |
99 | # При необходимости можно писать длинные цепочки JOIN
100 | # cursor.execute("""
101 | # SELECT *
102 | # FROM books
103 | # LEFT JOIN authors ON books.author_id = authors.id
104 | # LEFT JOIN reviews ON books.review_id = reviews.id
105 | # """)
106 |
107 | print(cursor.fetchall())
108 |
109 |
110 | con.commit()
111 | cursor.close()
112 | con.close()
113 |
--------------------------------------------------------------------------------
/lesson20/sql_relations.py:
--------------------------------------------------------------------------------
1 | # Реляционные базы данных
2 | # Внешний ключ - инструмент связывания двух таблиц БД
3 | import sqlite3
4 |
5 |
6 | con = sqlite3.connect('lesson20/db_second.db')
7 | cursor = con.cursor()
8 |
9 |
10 | # Предварительно удаляем таблицы, чтоб записи не накапливались
11 | # в них
12 | cursor.execute("DROP TABLE books")
13 | cursor.execute("DROP TABLE authors")
14 |
15 | # Создаем таблицу книг
16 | cursor.execute("""
17 | CREATE TABLE IF NOT EXISTS books(
18 | id INTEGER PRIMARY KEY AUTOINCREMENT,
19 | title VARCHAR(200),
20 | author_id INTEGER,
21 | year INTEGER(5),
22 | -- Строка ниже описывает, какое поле - внешний ключ,
23 | -- и что он указывает (другая таблица, ее поле)
24 | FOREIGN KEY(author_id) REFERENCES authors(id)
25 | );
26 | """)
27 |
28 | # Создаем таблицу авторов
29 | cursor.execute("""
30 | CREATE TABLE IF NOT EXISTS authors(
31 | id INTEGER PRIMARY KEY AUTOINCREMENT,
32 | name VARCHAR(60)
33 | );
34 | """)
35 |
36 | # Добавление нескольких записей в таблицу authors
37 | author_query = "INSERT INTO authors(name) VALUES(?)"
38 | author_data = [
39 | ('Лев Толстой',),
40 | ('Пушкин А. С.',),
41 | ('Берроуз',)
42 | ]
43 | cursor.executemany(author_query, author_data)
44 |
45 | # Добавление нескольких записей в таблицу books
46 | books_query = """
47 | INSERT INTO books(title, author_id, year)
48 | VALUES(?, ?, ?)
49 | """
50 | books_data = [
51 | ('Война и мир', 1, 1950),
52 | ('Джанки', 3, 1997),
53 | ('Анна Каренина', 1, 1877),
54 | ('Колобок', None, 1000)
55 | ]
56 | cursor.executemany(books_query, books_data)
57 |
58 | # Получаем данные из двух таблиц
59 | cursor.execute("""
60 | SELECT books.title, authors.name
61 | FROM books, authors
62 | WHERE books.author_id = authors.id
63 | """)
64 | print(cursor.fetchall())
65 |
66 |
67 | con.commit()
68 | cursor.close()
69 | con.close()
70 |
--------------------------------------------------------------------------------
/lesson21/my_db.db:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Intense-IT/Python2023/5dac21545e27bf3e8401915c962c8c5ca8770b68/lesson21/my_db.db
--------------------------------------------------------------------------------
/lesson21/my_requests.py:
--------------------------------------------------------------------------------
1 | # Библиотека requests для отправки запросов
2 | # https://requests.readthedocs.io/en/latest/
3 | # Перед импортом необходимо установить библиотеку через терминал
4 | # pip install requests
5 | import requests
6 |
7 |
8 | # Пример запроса к сайту - осуществляется через метод get()
9 | # В переменную response сохраняется ответ на запрос
10 | response = requests.get('https://requests.readthedocs.io/en/latest/user/quickstart/')
11 |
12 | print(response) # выводим в консоль объект ответа
13 |
14 | print(response.status_code) # выводим статус ответа
15 | # https://ru.wikipedia.org/wiki/Список_кодов_состояния_HTTP
16 |
17 | # print(response.content) # выводим содержимое ответа
18 |
19 | # print(response.text) # выводим содержимое ответа в виде текста
20 |
21 | # Документация к Static API Яндекс.Карт
22 | # https://yandex.ru/dev/staticapi/doc/ru/
23 |
24 | # Пример запроса к сервису Яндекс.карт
25 | # https://static-maps.yandex.ru/1.x/?ll=47.499175,42.974169&spn=0.005,0.005&l=map
26 | response = requests.get(
27 | 'https://static-maps.yandex.ru/1.x/?ll=47.499175,42.974169&spn=0.005,0.005&l=map')
28 | print(response.content)
29 |
30 | # Перепишем код запроса в более эффективную форму
31 | # Отдельная переменная для указания сервиса, куда делается запрос
32 | api_server = 'https://static-maps.yandex.ru/1.x/'
33 | # Отдельная переменная для словаря, хранящего все параметры
34 | map_params = {
35 | 'll': '47.499175,42.974169',
36 | 'spn': '0.005,0.005',
37 | 'l': 'map'
38 | }
39 | # В сам метод get() передаются последовательно обе переменные
40 | response = requests.get(api_server, params=map_params)
41 | print(response)
42 |
--------------------------------------------------------------------------------
/lesson21/my_responses.py:
--------------------------------------------------------------------------------
1 | # Программа, делающая запросы к сервису Геокодер API Яндекс.Карт
2 | # Ссылка на документацию Геокодер API Яндекс.Карт
3 | # https://yandex.ru/dev/geocode/doc/ru/
4 | import requests
5 |
6 | # Адрес сервиса, куда делается запрос
7 | geo_api_server = 'http://geocode-maps.yandex.ru/1.x/'
8 | # Передаваемые параметры, среди которых ключ API
9 | geo_params = {
10 | 'apikey': '39e26183-aaa8-4978-b294-d0b902ced272',
11 | 'geocode': 'Махачкала',
12 | 'format': 'json'
13 | }
14 | response = requests.get(geo_api_server, params=geo_params)
15 | # Полученный результат необходимо преобразовать из JSON
16 | json_response = response.json()
17 |
18 | # В результате мы получаем словарь с большим количеством данных
19 | # Далее мы с этими данными работаем
20 | toponym = json_response['response']['GeoObjectCollection']['featureMember'][0]['GeoObject']
21 |
22 | print(toponym['metaDataProperty']['GeocoderMetaData']['text'])
23 | print(toponym['Point']['pos'])
24 |
--------------------------------------------------------------------------------
/lesson21/repeat.py:
--------------------------------------------------------------------------------
1 | # Освежим все пройденное по теме Базы данных
2 | import sqlite3
3 |
4 |
5 | con = sqlite3.connect('lesson21/my_db.db')
6 | cursor = con.cursor()
7 |
8 | cursor.execute("""
9 | CREATE TABLE IF NOT EXISTS directors(
10 | id INTEGER PRIMARY KEY AUTOINCREMENT,
11 | name VARCHAR(100)
12 | );
13 | """)
14 | cursor.execute("""
15 | CREATE TABLE IF NOT EXISTS films(
16 | id INTEGER PRIMARY KEY AUTOINCREMENT,
17 | title VARCHAR(100),
18 | director INTEGER,
19 | year INTEGER(5),
20 | FOREIGN KEY(director) REFERENCES directors(id)
21 | );
22 | """)
23 |
24 | director_query = "INSERT INTO directors(name) VALUES(?);"
25 | director_query_data = [
26 | ('Роберт Земекис',),
27 | ('Зак Снайдр',)
28 | ]
29 | cursor.executemany(director_query, director_query_data)
30 |
31 | query = "INSERT INTO films(title, director, year) VALUES(?, ?, ?);"
32 | query_data = [
33 | ('Форест Гамп', 1, 1986),
34 | ('300', 2, 2004),
35 | ('Хранители', 2, 2007)
36 | ]
37 | cursor.executemany(query, query_data)
38 |
39 | cursor.execute("SELECT title, year FROM films")
40 | print(cursor.fetchall())
41 |
42 | cursor.execute("""
43 | SELECT films.title, directors.name
44 | FROM films
45 | JOIN directors ON films.director = directors.id
46 | """)
47 | print(cursor.fetchall())
48 |
49 | con.commit()
50 | cursor.close()
51 | con.close()
52 |
--------------------------------------------------------------------------------
/lesson22/cgi-bin/index.py:
--------------------------------------------------------------------------------
1 | print('''
2 |
3 |
4 |
5 |
6 | Document
7 |
8 |
9 |
10 |
Главная страница 2
11 |
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Nemo aperiam cupiditate repudiandae facilis quasi at earum velit odio pariatur omnis eum, veritatis in sed repellat hic accusamus adipisci eaque natus!
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Nemo aperiam cupiditate repudiandae facilis quasi at earum velit odio pariatur omnis eum, veritatis in sed repellat hic accusamus adipisci eaque natus1!