Python_Sandbox_202/ex1.py at main · WaterRaven/Python_Sandbox_202 · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
# Task 1
def is_even(x):
    if x < 0:
        print(f"Warning! Number {x} is negative")
    return bool(not x % 2)


def test_Task1():
    assert is_even(-240)
    assert not is_even(-17)
    assert is_even(0)
    assert is_even(12)
    assert not is_even(131)
    print("Task1 is correct")


# Task2
def generate_squares(min_num, max_num):
    return [i**2 for i in range(min_num, max_num+1)]


def test_Task2():
    assert generate_squares(0, 0) == [0]
    assert generate_squares(1, 5) == [1, 4, 9, 16, 25]
    assert generate_squares(-3, 3) == [9, 4, 1, 0, 1, 4, 9]
    assert generate_squares(5, 4) == []
    assert generate_squares(-5, -3) == [25, 16, 9]
    print("Task2 is correct")


# Task3
def split_list(l):
    return [i for i in l if i != 0]


def test_Task3():
    assert split_list([0]) == []
    assert split_list([0, 1, 2, 3]) == [1, 2, 3]
    assert split_list([1, 0, 23, 85, 0, 0, 74]) == [1, 23, 85, 74]
    assert split_list([0, 0, 1, 0]) == []
    assert split_list([]) == []
    print("Task3 is correct")


# Task4
def make_dict(l):
    str_list = [(i, len(i)) for i in l if isinstance(i, str)]
    num_list = [i for i in l if isinstance(i, int) or isinstance(i, float)]
    return {'str': str_list, 'num': num_list}


def test_Task4():
    assert make_dict([]) == {'str': [], 'num': []}
    assert make_dict([1, 2, 3, '1', '2', '3']) == {
        'str': [1, 2, 3], 'num': ['1', '2', '3']}
    assert make_dict(['to', 'be', 'or', 'not', 'to', 'be']) == {
        'str': ['to', 'be', 'or', 'not', 'to', 'be'], 'num': []}
    print("Task4 is correct")


# Task5
class Vector2D:

    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def norm(self):
        return (self.x**2+self.y**2)**0.5

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __lt__(self, other):
        return self.norm() < other.norm()

    def __le__(self, other):
        return self.norm() <= other.norm()

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

    def __ne__(self, other):
        return self.x != other.x and self.y != other.y

    def __gt__(self, other):
        return self.norm() > other.norm()

    def __ge__(self, other):
        return self.norm() >= other.norm()

# Task6
    def __add__(self, other):
        return Vector2D(self.x+other.x, self.y+other.y)

    def __sub__(self, other):
        return Vector2D(self.x-other.x, self.y-other.y)

    def __mul__(self, number):
        return Vector2D(self.x*number, self.y*number)

    def __rmul__(self, number):
        return Vector2D(self.x*number, self.y*number)


def test_Task5_Task6():
    vector_0 = Vector2D()
    vector_1 = Vector2D(1, 2)
    vector_2 = Vector2D(3, -4)
    vector_3 = Vector2D(1, 2)

    assert vector_2.norm() == 5
    assert vector_0.norm() == 0
    assert vector_1 == vector_3
    assert vector_2 > vector_3
    assert vector_2 >= vector_1
    assert vector_0 <= vector_1
    assert vector_0 < vector_3
    assert vector_0 != vector_2
    assert str(vector_1) == "(1, 2)"
    assert str(vector_2) == "(3, -4)"
    print("Task5 is correct")

    assert vector_1 + vector_2 == Vector2D(4, -2)
    assert vector_1 - vector_2 == Vector2D(-2, 6)
    assert vector_1 * 3 == Vector2D(3, 6)
    assert 2 * vector_2 == Vector2D(6, -8)
    print("Task6 is correct")


if __name__ == '__main__':
    test_Task1()
    test_Task2()
    test_Task3()
    test_Task4()
    test_Task5_Task6()