Fliffy ksenia

Practice/FliffyKsenia/lec.2.2.py

@@ -0,0 +1,6 @@
+start = input("Топлива было: ")
+distance = input("Расстояние: ")
+end = input("Топлива осталось: ")
+diff = int(start) - int(end)
+print (f"Result: {diff / int(distance)}")
+

Practice/FliffyKsenia/lec.3.5.py

@@ -0,0 +1,9 @@
+#используем функцию дляпроверки строки на палиндром
+def is_palindrom(slovo):
+    slovo = slovo.upper()
+    perevernutoe_slovo = slovo[::-1] #производим операцию со строками по перевороту слова
+    return slovo == perevernutoe_slovo #булевая операция сравнения изначального с перевернутым
+
+#запрашиваем слово для проверки палинрома input("Введите слово для проверки является ли оно палиндромом: ")
+a = input("Введите слово для проверки является ли оно палиндромом: ")
+print(is_palindrom(a)) #выводим результат работы функции из палиндрома

Practice/FliffyKsenia/lec.4.5.py

@@ -0,0 +1,56 @@
+#импортируем(подключаем) функцию random для возможности её использования:
+import random
+
+#объявляем переменныые min и max значения
+range_min = " "
+range_max = " "
+
+#объявляем цикл на ввод min  и max данных
+while True:
+
+    while not range_min.isdigit(): # проверка на то, что min значение являеся целым числом
+        range_min = input("Введите целое число, являющееся началом диапазона: ")
+    while not range_max.isdigit():# проверка на то, что max значение являеся целым числом
+        range_max = input("Введите целое число, являющееся концом диапазона: ")
+    range_min = int(range_min)
+    range_max = int(range_max)
+    if range_min >= range_max: # проверка на то, что min значение меньше max
+        print("Вы указали не корректный диапазон: ")
+        range_min = " "
+        range_max = " "
+    else:
+        break
+
+#вызываем рандом в указанном диапазоне чисел
+vybor_kompyter = random.randint(range_min, range_max)
+#print(vybor_kompyter)
+
+# пользователь должен ввести число, в указанном им раннее диапазоне для угадывания выбора компьютером
+ugadai_chislo = " "
+
+
+#объявляем цикл на ввод числа для угадывания
+while True:
+
+    # пользователь вводит число
+    ugadai_chislo = input("Попробуйте угадать число, выбранное компьютером в заданном ранее вами диапазоне: ")
+    # проверка на ввод пользователем числа, если введеное значение не является числом:
+    if not (ugadai_chislo.isdigit()):
+        #выход из программы
+        print("Пока! Жаль, что мы так быстро расстаемся! ")
+        break
+
+
+    # проверка на то, что заданное пользователем число больше или равно введеного им минимального значения
+    ugadai_chislo = int(ugadai_chislo)
+    if ugadai_chislo < range_min or ugadai_chislo > range_max:
+        print("Вы указали число, находящееся вне заданного ранее вами диапазона")
+     # проверка на то, что заданное пользователем число меньше или равно введеного им максимального значения
+    elif ugadai_chislo > vybor_kompyter:
+        print("Очень жаль, но вы не угадали. Вы ввели число больше, чем следовало: ")
+    elif ugadai_chislo < vybor_kompyter:
+        print("Очень жаль, но вы не угадали. Вы ввели число меньше, чем следовало: ")
+
+    else:
+        print("Поздравляю Вас, Вы угадали. У Вас прекрасный дар ясновиденья. Может Вам начать предоставлять услуги ясновиденья?")
+        break

Practice/FliffyKsenia/lec1.py

@@ -0,0 +1,8 @@
+x = input("Hello, enter x: ")
+y = input("Enter y: ")
+print(f"Result: {int(x)**int(y)}")
+input("Thanks")
+
+
+
+

Practice/FliffyKsenia/lec10.2.py

@@ -0,0 +1,16 @@
+message = ""   # Определяем переменную строкого типа
+while message != "ПОКА": #  делаем цикл, до момента пока с нами не попрощается пользователь.
+    message = input("->").upper()  #  делаем запрос пользователю. и переводим сразу в большие буквы, чтобы невилировать маленькие ошибки пользователя
+    match message:   #  проверяем ввод пользователя на соответсвие предопределенным фразам.
+        case "ПРИВЕТ":   #  Проверяем соответствует ли ввод пользоваеля предопределенной фразе "Привет"
+            print("Здраствуйте, давайте начнем наш диалог. Если вам надо можете сказать пока.") # Выводим заранее заданный ответ на фразу "Привет"
+        case "КАК ДЕЛА?":  #  Проверяем соответствует ли ввод пользоваеля предопределенной фразе "Как дела?"
+            print("Дела прекрассны, пока ни одной ошибки.") # Выводим заранее заданный ответ на фразу "Как дела?"
+        case "КАКАЯ СЕГОДНЯ ПОГОДА?":  #  Проверяем соответствует ли ввод пользоваеля предопределенной фразе "Какая сегодня  погода?"
+            print("Прекрасная, ведь у природы нет полохой погоды.") # Выводим заранее заданный ответ на фразу "Какая сегодня  погода?"
+        case "ПОКА": #  Проверяем соответствует ли ввод пользоваеля предопределенной фразе "пока"
+            print("До свидания.") #  прощаемся с пользователем
+        case _: #  Так как ни одной разе ссответсвие не нашлось, выводим сообщение о "некорректности"
+            print("Вопрос некорректен, попробуйте сформулировать его по-другому")  # Выводим сообщение о некорректности.
+
+

Practice/FliffyKsenia/lec11.1.py

@@ -0,0 +1,110 @@
+import time
+from threading import Thread
+import multiprocessing as mp
+
+start_1 = 3
+end_1 = 10000
+start_2 = 10001
+end_2 = 20000
+start_3 = 20001
+end_3 = 30000
+
+class MyError(Exception):
+    pass
+
+class Mythread(Thread):
+    def __init__(self,*args):  # переопределяем процедуру инициализации
+        Thread.__init__(self)  # выполняем процедуру инициализации из родительского класса
+        self.args = args
+    def run(self):  # описываем функцию которая начинает работать при старте потока.
+       self.lst = find_primes(*self.args)
+
+
+def superfun(fun):
+    def inner_fun(*args, **kwargs):
+        start = time.time()
+        res = fun(*args, **kwargs)
+        stop = time.time()
+        print(f"Execution time: {stop - start}")
+        return res
+
+    return inner_fun
+
+def find_primes(*args):
+    match len(args):
+        case 1:
+            start, end  = 3, args[0]
+        case 2:
+            start, end  = args[0],args[1]
+        case _:
+            raise MyError("too many arguments")
+
+    if start <= 2 and end > 2:
+        lst = [2]
+        start = 3
+    else:
+        lst = []
+    for i in range(start, end + 1, 2):
+
+        if not ((i > 10) and (i % 10 == 5)):
+
+            for j in range(3, i + 1, 2):
+                if (i % j == 0):
+                    break
+                if j * j > i:
+                    lst.append(i)
+                    break
+
+
+    return lst
+
+@superfun
+def pusk():
+    return find_primes(end_1) + find_primes(start_2, end_2) + find_primes(start_3, end_3)
+
+
+@superfun
+def thread_pusk():
+    mytread1 = Mythread(end_1)
+    mytread2 = Mythread(start_2,end_2)
+    mytread3 = Mythread(start_3,end_3)
+    mytread1.start()
+    mytread2.start()
+    mytread3.start()
+    mytread1.join()
+    mytread2.join()
+    mytread3.join()
+    return mytread1.lst + mytread2.lst + mytread3.lst
+
+
+
+def foo(*args):
+    args[0].put(find_primes(args[1],args[2]))
+
+
+
+@superfun
+def process_pusk():
+    mp.set_start_method('spawn')
+    q1 = mp.Queue()
+    q2 = mp.Queue()
+    q3 = mp.Queue()
+    p1 = mp.Process(target=foo, args=(q1,start_1,end_1))
+    p2 = mp.Process(target=foo, args=(q2,start_2,end_2))
+    p3 = mp.Process(target=foo, args=(q3,start_3,end_3))
+    p1.start()
+    p2.start()
+    p3.start()
+    p1.join()
+    p2.join()
+    p3.join()
+    return q1.get() + q2.get() + q3.get()
+
+
+if __name__ == '__main__':
+    print("Запускаем последовательно процедуру")
+    print(f"Найдено {len(pusk())} простых чисела")
+    print("Запускаем процедуру через потоки")
+    print(f"Найдено {len(thread_pusk())} простых чисела")
+    print("Запускаем через процессы")
+    print(f"Найдено {len(process_pusk())} простых чисела")

Practice/FliffyKsenia/lec12.1.client.py

@@ -0,0 +1,20 @@
+import socket
+import pickle
+
+
+def client_program(shifr):
+    host = socket.gethostname()  # получаем имя компьютера на котором запускается клиент, считаем, что сервер запущен на этом же ПК.
+    port = 5080  # порт к которому будем подключатся.
+    client_socket = socket.socket()  # инициализируем сокет
+    client_socket.connect((host, port))  # подключаемся к серверу
+    client_socket.send(pickle.dumps(shifr))  # отправляем сериаоизованный список
+    data = client_socket.recv(1024)  # ждем расшифрованные данные от сервера
+    print(f'Deciphered words: {pickle.loads(data)}')  # выводим расшифрованный список на экран
+    client_socket.close()  # Закрываем соединение
+
+
+if __name__ == '__main__':
+    # создаем список зашифрованных слов.
+    shifr = ['dasd', 'rewff', 'gvavasdf', 'fdasferv']
+    # вызываем клиент для подключения к серверу.
+    client_program(shifr)

Practice/FliffyKsenia/lec12.1.server.py

@@ -0,0 +1,34 @@
+import pickle
+import socket
+
+
+def server_program():
+    host = socket.gethostname()  # получаем имя ПК на котором запускается сервер
+    port = 5080  # выбираем порт на котором будем работать
+    server_socket = socket.socket()  # создаем сокет
+    server_socket.bind((host, port))  # подключаемся на выбранный нами порт для ожидания подключений от клиентов
+    server_socket.listen(2)  # выбираем максимальное количество клиентов.
+    conn, address = server_socket.accept()  # ждем подключение клиента
+    print("Connection from: " + str(address))  # выводим соощение, что клиент подключился
+    # создаем словарь для расшифровки
+    shifr_dict = {'dasd': 'hello', 'rewff': 'my', 'gvavasdf': 'dear', 'fdasferv': 'friend'}
+    while True:
+        # получаем данные от клиента
+        data = conn.recv(1024)
+        if not data:
+            break
+        # преобразуем получинные данные от клиента в список зашифрованных слов
+        shifrs = pickle.loads(data)
+        message = []
+        # проводим расшифровку слов согласно слованя
+        for shifr in shifrs:
+            # формируем массив расшифрованных слов.
+            message += [shifr_dict[shifr]]
+        # отправляем расшифрованный список назад клиенту.
+        conn.send(pickle.dumps(message))
+    conn.close()
+
+
+# запускаем сервер
+if __name__ == '__main__':
+    server_program()

Practice/FliffyKsenia/lec12.2.client1.py

@@ -0,0 +1,6 @@
+from lec12_2_imports import User
+from lec12_2_imports import client_program
+
+# Создаем объект типа юзер именем и возрастом.
+user = User("Jack", 28)
+client_program(user)

Practice/FliffyKsenia/lec12.2.client2.py

@@ -0,0 +1,6 @@
+from lec12_2_imports import User
+from lec12_2_imports import client_program
+
+# Создаем объект типа юзер именем и возрастом.
+user = User("Mary",24)
+client_program(user)

Practice/FliffyKsenia/lec12.2.server.py

@@ -0,0 +1,86 @@
+# сервер который ждет подключения от клиентов, и при каждом новом подключении выдает список активных клиентов с именами пользователей.
+import socket
+import pickle
+from threading import Thread
+from lec12_2_imports import User
+
+PORT = 5089
+
+
+# создаем класс для создания потока который будет обрабатывать входящие соединения
+class Server_thread(Thread):
+    def __init__(self, conn, addr):  # переопределяем процедуру инициализации
+        Thread.__init__(self)  # выполняем процедуру инициализации из родительского класса
+        self.conn, self.addr = conn, addr  # сохраняем в свойства данные о соединении
+        self.notready = True  # создаем парамерт, который сообщает нам получили ли мы данные о пользователе или нет. True не получили, False  получили
+        self.not_die = True
+
+    def server_stop(self):
+        self.conn.settimeout(1)
+        self.conn.close()
+        self.conn.detach()
+
+    def run(self):  # описываем функцию которая начинает работать при старте потока.
+        while True:
+            data = self.conn.recv(1024)  # принимаем данные от клиента
+            if not data:
+                self.conn.close()  # если нет данных закрываем соединиение
+                self.not_die = False
+                break  # выходим из потока, завершая его.
+            else:
+                self.user = pickle.loads(
+                    data)  # обрабатываем данные от клиента и создаем переменную внутри класса типа юзер.
+                self.notready = False  # сообщаем классу, что мы получили данные о пользователе
+
+
+class Server_main(Thread):
+    def __init__(self, port):
+        Thread.__init__(self)
+        self.port = port  # задаем имя порта на котором будем ждать соединения
+        self.threads = []  # объявляем массив для хранения текущих подключений
+
+    def server_stop(self):
+        self.server_start = False  # говорим серверу, что рабочий день закончен.
+        for t in self.threads:  # обходим живые потоки
+            t.server_stop()  # говорим им, что рабочий день закончен.
+        client_socket = socket.socket()  # инициализируем сокет для того, чтобы закрыть сервер, надо выйти из состояния ожидания соединения. для этого фиктивно конектимся. по факту этим говори стоп.
+        client_socket.connect((self.host, self.port))  # подключаемся к серверу
+        user = User("", 0)  # создаем фикивного пользователя, чтбы не вызывать ошибку.
+        client_socket.send(pickle.dumps(user))  # запаковываем объект типа юзер и передаем его серверу.
+        client_socket.close()  # закрываем соединиение
+
+    def run(self):
+        self.server_start = True  # переменная состояния сервера.
+        self.host = socket.gethostname()  # получаем имя текущего компа на котором запустился наш сервер
+        self.server_socket = socket.socket()  # создаем сокет
+        self.server_socket.bind((self.host, self.port))  # открываем заданный порт для прослушивания
+        self.server_socket.listen(20)  # задаем количество возможных соединений
+        while self.server_start:
+            conn, addr = self.server_socket.accept()  # ждем подключения
+            threada = Server_thread(conn, addr)  # создаем и запускаем новый поток для обработки данных от клиента
+            threada.start()  # запускаем новый поток.
+            self.threads.append(threada)  # добавляем наш поток в список активных потоков
+        self.server_socket.close()  # закрываем соединение
+
+    def connected_users(self):
+        print("Connected users:")  # выводим список подключенных пользователей
+        for thread in self.threads:  # обходим массив активных соединений.
+            if thread.not_die:  # проверяем на живость потока, если умер, то удаляем из массыва живых потоков.
+                while thread.notready:  # ждем когда прийдет информация о пользователе
+                    pass
+                print(f"name: {thread.user.name}, age: {thread.user.age}")  # выводим данные об активном соединении
+            else:
+                self.threads.remove(thread)  # удаляем умерший поток
+
+
+is_runinng = ""
+myserver = Server_main(PORT)  # создаем поток сервера.
+myserver.start()  # запускаем сервер в отдельном потоке.
+
+while is_runinng != "bye":
+    is_runinng = input(
+        "Введите bye для выхода, или любой текст для просмотра подключенных клиентов:")  # ждем команды пользователя
+    myserver.connected_users()  # выводим текущие соединения.
+
+myserver.server_stop()  # останавливаем сервер.
+print("Bye!")