<repo_name>apryab/GeekBrains-HW-7<file_sep>/Task 2.py
from abc import ABC, abstractmethod


def my_decorator(func):

    def wrapper(self):
        if hasattr(self, 'size'):
            print('Количество ткани для пальто -', end=' ')
        if hasattr(self, 'height'):
            print('Количество ткани для костюма -', end=' ')
        answer = func(self)
        print(answer)
    return wrapper


class Clothes(ABC):

    @abstractmethod
    def __init__(self):
        pass

    @abstractmethod
    def fabric_count(self):
        pass


class Coat(Clothes):

    def __init__(self, size):
        super().__init__()
        try:
            self.size = int(size)
        except(TypeError, ValueError):
            print('Неправильный формат роста. Будет присвоено значение -1')
            self.size = -1

    @my_decorator
    def fabric_count(self):
        if self.size <= 0:
            raise ValueError
        else:
            return self.size / 6.5 + 0.5


class Costume(Clothes):

    def __init__(self, height):
        super().__init__()
        try:
            self.height = float(height)
        except(TypeError, ValueError):
            print('Неправильный формат роста, надо ввести число.')
            self.height = -1

    @my_decorator
    def fabric_count(self):
        if self.height <= 0:
            raise ValueError
        else:
            return 2 * self.height + 0.3


my_coat_1 = Coat(5)
my_costume = Costume(4)
my_coat_2 = Coat('r')
try:
    my_coat_1.fabric_count()
    my_costume.fabric_count()
    my_coat_2.fabric_count()
except(TypeError, ValueError):
    print('\n')
    print('Неправильный формат данных у объекта')
<file_sep>/Task 1.py
import copy


class Matrix:

    def __init__(self, my_list):
        mistake = 0
        try:
            len(my_list)
        except TypeError:
            print('Матрица должна быть списком списков')
            mistake = 1
        if mistake != 1:
            if len(my_list) > 0:
                try:
                    n = len(my_list[0])
                except TypeError:
                    print('Матрица должна быть списком списков')
                    n = -1
                    mistake = 1
                try:
                    if mistake != 1:
                        for elem in my_list:
                            if len(elem) != n:
                                mistake = 1
                                break
                            for item in elem:
                                float(item)
                except(ValueError, TypeError):
                    print('Неправильный формат данных в матрице')
                    mistake = 1
                if mistake == 0:
                    self.height = len(my_list)
                    self.width = len(my_list[0])
                    self.list = my_list
            else:
                mistake = 1
            if mistake == 1:
                self.height = 0
                self.width = 0
                self.list = []
                print('Будет создана матрица нулевого размера')

    def __str__(self):
        big_str = '['
        for elem in self.list:
            big_str += '['
            for item in elem:
                big_str += str(item)
                big_str += ', '
            if self.width > 0:
                big_str = big_str[:-2]
            big_str += ']'
            big_str += ', '
        if self.height > 0:
            big_str = big_str[:-2]
        big_str += ']'
        return big_str

    def __add__(self, other):
        if type(other) == Matrix:
            if(self.width == other.width) and (self.height == other.height):
                answer_list = []
                for i in range(len(self.list)):
                    temp_list = []
                    for j in range(len(self.list[i])):
                        temp_list.append(self.list[i][j] + other.list[i][j])
                    answer_list.append(copy.deepcopy(temp_list))
                    temp_list.clear()
                return Matrix(answer_list)
            else:
                print('Размеры матриц не равны')
                return ValueError
        else:
            print('Неправильные типы данных операндов')
            return TypeError


my_matrix_1 = Matrix([[1, 100, 6], [2, 5, 1], [5, 8, 1]])
my_matrix_2 = Matrix([[2, 5, 8], [1, 4, 2], [2, 7, 3]])
answer_matrix = my_matrix_1 + my_matrix_2
print(answer_matrix)
<file_sep>/Task 3.py
class Cell:

    def __init__(self, numb_of_cells):
        try:
            self.numb_of_cells = float(numb_of_cells)
            if self.numb_of_cells % 1 == 0:
                self.numb_of_cells = int(self.numb_of_cells)
                if self.numb_of_cells == 0:
                    print('В ячейке не может быть 0 клеток. Будет создана единичная клетка')
                    self.numb_of_cells = 1
            else:
                print('Неправильный формат данных. Будет создана единичная клетка')
                self.numb_of_cells = 1
        except(ValueError, TypeError):
            print('Ошибка в формате данных. Будет создана единичная клетка')
            self.numb_of_cells = 1

    def __add__(self, other):
        if type(other) == Cell:
            sum_of_two = self.numb_of_cells + other.numb_of_cells
            return Cell(sum_of_two)
        else:
            print('Неправильный тип операндов. Будет создана единичная клетка')
            return Cell(1)

    def __mul__(self, other):
        if type(other) == Cell:
            multi_of_two = self.numb_of_cells * other.numb_of_cells
            return Cell(multi_of_two)
        else:
            print('Неправильный тип операндов. Будет создана единичная клетка')
            return Cell(1)

    def __sub__(self, other):
        if type(other) == Cell:
            sub_of_two = self.numb_of_cells - other.numb_of_cells
            if sub_of_two <= 0:
                print('Клеток в ячейке не может быть меньше нуля. Будет создана единичная клетка')
                return Cell(1)
            else:
                return Cell(sub_of_two)
        else:
            print('Неправильный тип операндов. Будет создана единичная клетка')
            return Cell(1)

    def __truediv__(self, other):
        if type(other) == Cell:
            div_of_two = self.numb_of_cells // other.numb_of_cells
            if div_of_two != 0:
                return Cell(div_of_two)
            else:
                print('Количество ячеек в первой клетке должно быть больше чем во второй.', end=' ')
                print('Будет создана единичная клетка')
                return Cell(1)
        else:
            return Cell(1)

    def make_order(self, numb_in_row):
        try:
            row_numb = float(numb_in_row)
            answer_str = ''
            if row_numb != 0:
                if row_numb % 1 == 0:
                    row_numb = int(row_numb)
                    for i in range(1, self.numb_of_cells + 1):
                        answer_str += '*'
                        if i % row_numb == 0:
                            if i != self.numb_of_cells:
                                answer_str += '\n'
                    return answer_str
                else:
                    print('Неправильный формат данных. Будет создана пустая строка')
                    return ''
            else:
                print('Ячеек в ряду не может быть ноль. Будет создана пустая строка')
                return ''

        except(TypeError, ValueError):
            print('Введите целое число в качестве длины строки. Будет создана пустая строка')
            return ''


my_cell_1 = Cell(8)
my_cell_2 = Cell(5)
my_cell_3 = Cell(5.3)
print((my_cell_1 + my_cell_2).numb_of_cells)
print((my_cell_1 - my_cell_2).numb_of_cells)
print((my_cell_1 * my_cell_2).numb_of_cells)
print((my_cell_1 / my_cell_2).numb_of_cells)
print(my_cell_1.make_order(0))
<file_sep>/README.md
# GeekBrains-HW-7
Домашние задания для изучения Python
