Д.з. по модулю 9 "Работа с объектами Python"

Practice/nskorokhodova/Practice_lec_10_task1.py

@@ -0,0 +1,12 @@
+#Используя модуль re, найти все команды Git с аргументами в файле Practice/README.md
+import re
+
+
+lst = []
+with open(r"C:\Users\..\Practice\README.md", "r", encoding="utf-8'") as f:
+    reg = re.compile(r"git\s\w*")
+    for line in f:
+        line = line.rstrip('\n')
+        lst += re.findall(reg, line)
+    for i in lst:
+        print(i)

Practice/nskorokhodova/Practice_lec_10_task2.py

@@ -0,0 +1,32 @@
+from datetime import datetime, timedelta
+
+
+def count_working_days(start_date, end_date):
+    start_date = datetime.strptime(start_date, "%Y-%m-%d")
+    end_date = datetime.strptime(end_date, "%Y-%m-%d")
+
+    holidays = [
+        datetime(2023, 1, 1),
+        datetime(2023, 3, 8),
+        datetime(2023, 5, 1),
+        datetime(2023, 5, 9),
+        datetime(2023, 6, 12),
+        datetime(2023, 11, 4),
+    ]
+
+    working_days = 0
+
+    current_date = start_date
+    while current_date <= end_date:
+        if current_date.weekday() < 5 and current_date not in holidays:
+            working_days += 1
+
+        current_date += timedelta(days=1)
+    return working_days
+
+
+start_date = "2023-01-01"
+end_date = "2023-01-31"
+
+result = count_working_days(start_date, end_date)
+print("Количество рабочих дней:", result)

Practice/nskorokhodova/Practice_lec_10_task3.py

@@ -0,0 +1,30 @@
+import os
+import time
+import shutil
+
+
+def delete_files_and_folders(path, expiration_time):
+    current_time = time.time()
+
+    try:
+        for root, dirs, files in os.walk(path):
+            for file_name in files:
+                file_path = os.path.join(root, file_name)
+
+                creation_time = os.path.getctime(file_path)
+
+                if (current_time - creation_time) > expiration_time:
+                    os.remove(file_path)
+
+            for dir_name in dirs:
+                dir_path = os.path.join(root, dir_name)
+
+                creation_time = os.path.getctime(dir_path)
+
+                if (current_time - creation_time) > expiration_time:
+                    shutil.rmtree(dir_path)
+
+        print("Файлы и папки, у которых истек срок:", path)
+
+    except Exception as e:
+        print("Ошибка при удалении файлов и папок:", str(e))

Practice/nskorokhodova/Practice_lec_10_task4.py

@@ -0,0 +1,40 @@
+import pickle
+import random
+
+
+class Human:
+    def __init__(self, name, surname, age, address):
+        self.name = name
+        self.surname = surname
+        self.age = age
+        self.address = address
+
+
+def create_humans(num_humans):
+    humans = []
+    for _ in range(num_humans):
+        name = random.choice(["Иван", "Мария", "Михаил", "Александр", "Алла"])
+        surname = random.choice(["Иванов", "Олешко", "Смирнов", "Моисеев", "Копытова"])
+        age = random.randint(18, 65)
+        address = random.choice(["Москва", "Лондон", "Нижний Новгород", "Пермь", "Омск"])
+        human = Human(name, surname, age, address)
+        humans.append(human)
+    return humans
+
+
+def serialize(humans):
+    with open("human.data", "wb") as file:
+        pickle.dump(humans, file)
+
+
+def deserialize():
+    with open("human.data", "rb") as file:
+        humans = pickle.load(file)
+        for human in humans:
+            print(human.name, human.surname, human.age, human.address)
+
+
+x = int(input("Введите число "))
+p = create_humans(x)
+serialize(p)
+deserialize()

Practice/nskorokhodova/Practice_lec_9_task1.py

@@ -0,0 +1,30 @@
+class ParagraphIterator:
+    def __init__(self, text, paragraph_separator):
+        self.text = text
+        self.paragraph_separator = paragraph_separator
+        self.paragraphs = self.text.split(self.paragraph_separator)
+        self.index = 0
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self.index >= len(self.paragraphs):
+            raise StopIteration
+        else:
+            paragraph = self.paragraphs[self.index]
+            self.index += 1
+            return paragraph
+
+
+text = """
+В лесу родилась елочка. В лесу она росла.
+Зимой и летом стройная.
+Зеленая была.
+"""
+
+paragraph_separator = '.'
+paragraphs = ParagraphIterator(text, paragraph_separator)
+
+for paragraph in paragraphs:
+    print(paragraph)

Practice/nskorokhodova/Practice_lec_9_task2.py

@@ -0,0 +1,8 @@
+def read_file(file_path):
+    with open(file_path, 'r') as file:
+        for line in file:
+            yield line.rstrip('\n')
+
+file_path = 'C:\Python\python.exe\..\Files\info.txt'
+for line in read_file(file_path):
+    print(line)

Practice/nskorokhodova/Practice_lec_9_task3.py

@@ -0,0 +1,14 @@
+import time
+
+
+class MyTime:
+    def __enter__(self):
+        self._start_time = time.time()
+        print("Начало исполнения кода")
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        print(f"Время исполнения {time.time() - self._start_time}")
+
+
+with MyTime():
+    time.sleep(1)

Practice/nskorokhodova/Practice_lec_9_task4.py

@@ -0,0 +1,24 @@
+import itertools
+
+
+def my_iter_merge(arr1, arr2, arr3):
+    return list(itertools.chain(arr1 + arr2 + arr3))
+
+
+def my_iter_len(arr):
+    return list(filter(lambda x: len(x) >= 5, arr))
+
+
+def my_iter_comb(my_pass):
+    for i in itertools.combinations(my_pass, 4):
+        print(i)
+
+
+first_task = ([1, 2, 3], [4, 5], [6, 7])
+print(my_iter_merge(*first_task))
+
+second_task = (["hello", "i", "write", "cool", "code"])
+print(my_iter_len(second_task))
+
+third_task = "password"
+my_iter_comb(third_task)

Practice/nskorokhodova/Practice_mod13_task1_client.py

@@ -0,0 +1,24 @@
+import socket
+import pickle
+
+def send_data(data):
+    host = 'mynet'
+    port = 13579
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.connect((host, port))
+
+        send_data = pickle.dumps(data)
+        s.sendall(send_data)
+
+        recv_data = s.recv(1024)
+
+        decoded_data = pickle.loads(recv_data)
+
+        return decoded_data
+
+
+if __name__ == "__main__":
+    encrypted_words = ['par**', 'is***bul', 'Li**on', 'lon**n']
+    decrypted_words = send_data(encrypted_words)
+    print(decrypted_words)

Practice/nskorokhodova/Practice_mod13_task1_server.py

@@ -0,0 +1,52 @@
+import socket
+import pickle
+
+def decrypt_words(encrypted_words):
+    dictionary = {
+        'par**': 'Paris',
+        'is***bul': 'Istanbul',
+        'Li**on': 'Lisbon',
+        'lon**n': 'London'
+    }
+    decrypted_words = []
+
+    for word in encrypted_words:
+        decrypted_word = dictionary.get(word)
+        decrypted_words.append(decrypted_word)
+
+    return decrypted_words
+
+
+def handle_client(conn):
+    recv_data = conn.recv(1024)
+
+    encrypted_words = pickle.loads(recv_data)
+
+    decrypted_words = decrypt_words(encrypted_words)
+
+    send_data = pickle.dumps(decrypted_words)
+
+    conn.sendall(send_data)
+
+    conn.close()
+
+
+def start_server():
+    host = 'mynet'
+    port = 13579
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind((host, port))
+        s.listen()
+
+        print("Server started.")
+
+        while True:
+            conn, addr = s.accept()
+            print(f"Client connected: {addr}")
+
+            handle_client(conn)
+
+
+if __name__ == "__main__":
+    start_server()

Practice/nskorokhodova/Practice_mod_12_task1.py

@@ -0,0 +1,65 @@
+import math
+import time
+import threading
+import multiprocessing
+
+
+def is_prime(num):
+    if num < 2:
+        return False
+    for i in range(2, int(math.sqrt(num)) + 1):
+        if num % i == 0:
+            return False
+    return True
+
+
+def find_primes(end, start=3):
+    primes = []
+    for num in range(start, end + 1):
+        if is_prime(num):
+            primes.append(num)
+    return primes
+
+
+if __name__ == '__main__':
+    t1 = threading.Thread(target=find_primes, args=(10000,))
+    t2 = threading.Thread(target=find_primes, args=(20000, 10001,))
+    t3 = threading.Thread(target=find_primes, args=(30000, 20001,))
+
+    start_time = time.time()
+    t1.start()
+    t2.start()
+    t3.start()
+    print("Потоки запущены")
+
+    start = time.perf_counter()
+    threads = []
+    for args in ((10000, 3), (20000, 10001), (30000, 20001)):
+        thr = threading.Thread(target=find_primes, args=args)
+        thr.start()
+        threads.append(thr)
+    for j in threads:
+        j.join()
+
+    print(f'Общее время вычислений потоков в секундах: {time.perf_counter() - start}\n')
+
+    p1 = multiprocessing.Process(target=find_primes, args=(10000,))
+    p2 = multiprocessing.Process(target=find_primes, args=(20000, 10001,))
+    p3 = multiprocessing.Process(target=find_primes, args=(30000, 20001,))
+
+    start_time = time.time()
+    p1.start()
+    p2.start()
+    p3.start()
+    print("Процессы запущены")
+
+    start = time.perf_counter()
+    proc = []
+    for args_proc in ((10000, 3), (20000, 10001), (30000, 20001)):
+        p = multiprocessing.Process(target=find_primes, args=args_proc)
+        p.start()
+        proc.append(p)
+    for pr in proc:
+        pr.join()
+
+    print(f'Общее время вычислений процессов в секундах: {time.perf_counter() - start}\n')

Practice/nskorokhodova/Practice_modul15_task1.py

@@ -0,0 +1,50 @@
+Привести два примера предметной области, для представления которых лучше использовать NoSQL-подход.
+Аргументировать ответ, используя критерии выбора между SQL и NoSQL.
+
+
+______________________________________________________________________________________________________________
+База данных SQL – это реляционная база данных который организует данные в таблицы со строками и столбцами. SQL означает язык структурированных запросов, который является стандартным языком, используемым для запроса и управления данными в реляционной базе данных.
+
+Некоторые ключевые характеристики базы данных SQL включают в себя:
+
+Данные хранятся в таблицах, содержащих строки и столбцы. Каждая строка представляет запись, а каждый столбец представляет атрибут этой записи.
+Между таблицами существуют связи, которые обеспечиваются с помощью внешних ключей. Это обеспечивает целостность данных и уменьшает избыточность.
+Язык SQL используется для запроса данных и управления ими. SQL предоставляет такие команды, как SELECT, INSERT, UPDATE и DELETE, для взаимодействия с базой данных.
+Свойства ACID (атомарность, согласованность, изоляция, долговечность) применяются для обеспечения надежности и целостности данных. Транзакции либо завершаются полностью, либо не завершаются вообще.
+
+База данных NoSQL — это нереляционная база данных который хранит данные в формате, отличном от строк и столбцов. Базы данных NoSQL бывают разных типов в зависимости от модели данных. Основные типы:
+
+Хранилища «ключ-значение». Данные хранятся в неструктурированном формате с уникальным ключом для извлечения значений. (Redis).
+Базы данных документов: данные хранятся в формате документа, например JSON. (MongoDB).
+Базы данных графов. Данные хранятся в узлах и ребрах, оптимизированных для взаимоотношений между данными.(Neo4j и JanusGraph).
+Столбчатые базы данных: данные хранятся в столбцах, а не в строках.(Cassandra).
+
+
+________________________________________________________________________________________________________________________-
+
+1.  Социальные сети.
+Социальные сети характеризуются большим объемом данных, высокой скоростью их прихода и изменения,
+а также необходимостью горизонтального масштабирования.
+В такой предметной области лучше использовать NoSQL-подход, так как он позволяет эффективно
+обрабатывать и хранить большие объемы данных с использованием горизонтального масштабирования.
+NoSQL базы данных обеспечивают отказоустойчивость и высокую производительность,
+что очень важно для социальных сетей с миллионами пользователей.
+Реляционность данных - это количество взаимосвязей между данными.Если предметную область можно представить в виде нескольких отдельных словарей - то реляционность слабая. В случае социальных сетей основная информация - это пользователь и его данные. Т.е. у нас получается, один большой список пользователей, и у каждого пользователя - набор атрибутов (имя, аватар, статус и т.д.).
+Пользовательские запросы, в основном, будут такие: найти пользователя по id (это когда мы страничку пользователя открываем), искать пользователей по каким-то другим критериям. Аналогично - для списка музыки, списка видео и т.д.
+Важный момент: сами медиа-файлы обычно хранятся отдельно на диске (как обычные файлы, либо в спец. хранилище, типа Amazon S3); в базу данных (что SQL, что NoSQL) их тащить не надо; в базе данных хранятся только пути к этим файлам в виде обычных строк.
+Поэтому критерии реляционности и пользовательских запросов также говорят в пользу NoSQL: данные нереляционные, пользовательские запросы простые.
+
+
+2. Маркетплэйс ( типа Ozon, Wildberries  и т.д.)
+Здесь требуется высокая скорость, т.к. может поступать много запросов, нужно
+делать много изменений ( добавлять/удалять поставщиков, товары и т.д.),
+поэтому лучше использовать NoSQL.
+Но в то же время много различных взаимосвязей товары - цены, покупатели - заказы,
+покупатели - статус заказа  и т.д. и большое количество потенциальных запросов
+( поиск товаров, поиск продавца и т.д.)  - решает более эффективно SQL.
+SQL-базы данных обычно используют реляционную модель, где данные хранятся в таблицах, связанных с друг другом. Данные в таблицах структурированы по строгим правилам и могут быть связаны с помощью внешних ключей. Эта структура данных делает SQL-базы данных хорошо подходящими для хранения и обработки структурированных данных. Однако эта модель не подходит для хранения неструктурированных данных, таких как изображения, звуковые файлы, видеоматериалы и т. д.
+Медиа-файлы обычно хранятся отдельно на диске, в базе данных они представлены обычными строками, в которых хранятся пути к этим файлам.
+В случае маркетплейсов данные вроде бы имеют множество взаимосвязей: товары с продавцами, товары с категориями и т.д. Но пользовательские запросы к маркетплейсу, на самом деле, весьма однообразны: нужен список товаров, отфильтрованных по какому-либо признаку. Получается, что нам для хранения данных достаточно большой коллекции документов (товаров), где у каждого документа будет ряд атрибутов (например, категория, цвет, размер, продавец и т.д.). Выносить по правилам реляционных СУБД связи, например, товара и продавца необязательно (тем более конкретный товар всегда жестко привязан к конкретному продавцу). А значит, и объединения таблиц (да и сами таблицы) не требуются. На самом деле, вид, в котором товары отображаются в поисковике маркетплейса, почти повторяет тот вид, в котором они хранятся в его БД.
+Анализ по критериям реляционности и потенциальных запросов обычно выполняется совместно и зачастую сводится к ответу на вопрос: можно ли представить сущности этой предметной области в виде нескольких отдельных словарей.
+Исходя из этого я сделала вывод, что в случае с маркетплэйсами все таки лучше использовать NoSQL.
+