|
4 | 4 | "cell_type": "markdown", |
5 | 5 | "metadata": {}, |
6 | 6 | "source": [ |
7 | | - "# Workshop 2: Задачи по теми 3 и 4 (ООП и функционално програмиране)" |
| 7 | + "# Workshop 2" |
8 | 8 | ] |
9 | 9 | }, |
10 | 10 | { |
11 | 11 | "cell_type": "markdown", |
12 | 12 | "metadata": {}, |
13 | 13 | "source": [ |
14 | | - "## Задача 1 – `Fraction`\n", |
15 | | - "\n", |
16 | | - "Напишете клас `Fraction`, който представя обикновена дроб и се държи като \"истинско\" число в Python.\n", |
17 | | - "\n", |
18 | | - "**Създаване и представяне**\n", |
19 | | - "* `Fraction(numerator, denominator=1)` – дробта винаги се пази **съкратена**, а знакът е в числителя (`Fraction(2, -4)` е същото като `Fraction(-1, 2)`). Приемаме, че знаменателят никога не е 0.\n", |
20 | | - "* `numerator` и `denominator` – само за четене\n", |
21 | | - "* клас-метод `Fraction.parse(text)`, който приема низове като `\"3/4\"`, `\"-5\"`, `\" 2 / -6 \"`\n", |
22 | | - "* `repr` → `\"Fraction(1, 2)\"`, `str` → `\"1/2\"` (или само `\"3\"`, ако знаменателят е 1)\n", |
23 | | - "\n", |
24 | | - "**Аритметика**\n", |
25 | | - "* `+`, `-`, `*`, `/` между две дроби, **както и между дроб и `int` – от двете страни** (`1 + Fraction(1, 2)`, `Fraction(1, 2) * 3`)\n", |
26 | | - "* унарен минус, `abs(...)`, `**` с цяла (и отрицателна!) степен\n", |
27 | | - "* `sum([...])` върху списък от дроби трябва да работи\n", |
28 | | - "\n", |
29 | | - "**Сравнение и конвертиране**\n", |
30 | | - "* `==`, `!=`, `<`, `<=`, `>`, `>=` – с дроби и с `int`\n", |
31 | | - "* `Fraction(4, 2) == 2` и `hash(Fraction(4, 2)) == hash(2)` (равни обекти трябва да имат равни хешове)\n", |
32 | | - "* сравнение с други типове (напр. `str`) не трябва да гърми, а просто да е `False` за `==`\n", |
33 | | - "* `float(...)`, `int(...)` (отрязва дробната част, като `int(-3.5)`), `bool(...)`\n", |
34 | | - "\n", |
35 | | - "* Hint: `math.gcd`, `__radd__` & co., `NotImplemented`" |
36 | | - ] |
37 | | - }, |
38 | | - { |
39 | | - "cell_type": "code", |
40 | | - "execution_count": null, |
41 | | - "metadata": {}, |
42 | | - "outputs": [], |
43 | | - "source": [ |
44 | | - "class Fraction:\n", |
45 | | - " pass # your code here\n", |
46 | | - "\n", |
47 | | - "\n", |
48 | | - "# Tests:\n", |
49 | | - "\n", |
50 | | - "half, third = Fraction(1, 2), Fraction(1, 3)\n", |
51 | | - "\n", |
52 | | - "# creation\n", |
53 | | - "assert Fraction(2, 4) == half\n", |
54 | | - "assert (Fraction(2, -4).numerator, Fraction(2, -4).denominator) == (-1, 2), \"the sign goes in the numerator\"\n", |
55 | | - "assert isinstance(Fraction.numerator, property) and Fraction.numerator.fset is None, \"numerator should be read-only\"\n", |
56 | | - "assert Fraction.parse(\"3/4\") == Fraction(3, 4)\n", |
57 | | - "assert Fraction.parse(\"-5\") == Fraction(-5)\n", |
58 | | - "assert Fraction.parse(\" 2 / -6 \") == Fraction(-1, 3)\n", |
59 | | - "assert repr(half) == \"Fraction(1, 2)\" and str(half) == \"1/2\" and str(Fraction(6, 3)) == \"2\"\n", |
60 | | - "\n", |
61 | | - "# arithmetic\n", |
62 | | - "assert half + third == Fraction(5, 6)\n", |
63 | | - "assert half - third == Fraction(1, 6)\n", |
64 | | - "assert half * third == Fraction(1, 6)\n", |
65 | | - "assert half / third == Fraction(3, 2)\n", |
66 | | - "assert half + 1 == Fraction(3, 2) and 1 + half == Fraction(3, 2), \"int on both sides\"\n", |
67 | | - "assert 1 - half == half and 2 * third == Fraction(2, 3) and 1 / third == 3\n", |
68 | | - "assert -half == Fraction(-1, 2) and abs(Fraction(-3, 4)) == Fraction(3, 4)\n", |
69 | | - "assert Fraction(2, 3) ** 2 == Fraction(4, 9)\n", |
70 | | - "assert Fraction(2, 3) ** -2 == Fraction(9, 4)\n", |
71 | | - "assert Fraction(-2, 3) ** -1 == Fraction(-3, 2), \"the sign must stay in the numerator\"\n", |
72 | | - "assert sum([half, half, third, third, third]) == 2\n", |
73 | | - "\n", |
74 | | - "# comparison\n", |
75 | | - "assert third < half <= half < 1 and 1 > half >= third\n", |
76 | | - "assert Fraction(4, 2) == 2 and 2 == Fraction(4, 2)\n", |
77 | | - "assert half != third and half != 1\n", |
78 | | - "assert half != \"1/2\", \"comparison with other types should not crash\"\n", |
79 | | - "assert sorted([Fraction(3, 4), 0, third, half]) == [0, third, half, Fraction(3, 4)]\n", |
80 | | - "assert len({Fraction(1, 2), Fraction(2, 4), Fraction(-3, -6)}) == 1\n", |
81 | | - "assert hash(Fraction(4, 2)) == hash(2)\n", |
82 | | - "assert len({2, Fraction(4, 2)}) == 1\n", |
83 | | - "\n", |
84 | | - "# conversion\n", |
85 | | - "assert float(Fraction(3, 4)) == 0.75\n", |
86 | | - "assert int(Fraction(7, 2)) == 3 and int(Fraction(-7, 2)) == -3\n", |
87 | | - "assert not Fraction(0, 5) and Fraction(1, 5)\n", |
88 | | - "\n", |
89 | | - "\"✅ All OK!\"" |
90 | | - ] |
91 | | - }, |
92 | | - { |
93 | | - "cell_type": "markdown", |
94 | | - "metadata": {}, |
95 | | - "source": [ |
96 | | - "## Задача 2 – Библиотека\n", |
97 | | - "\n", |
98 | | - "Моделирайте система за библиотека. Времето ще меряме в **дни** (цели числа, ден 0, ден 1, ...).\n", |
99 | | - "\n", |
100 | | - "**Абстрактен клас `Item(title)`**\n", |
101 | | - "* всеки създаден обект (от който и да е наследник) получава уникален `id` – поредно число, с 1 по-голямо от това на предишния създаден обект\n", |
102 | | - "* абстрактни property-та `loan_days` (за колко дни се заема) и `daily_fee` (глоба на ден закъснение)\n", |
103 | | - "* клас-атрибут `MAX_FEE` – максимална глоба за един заем (`None` = без таван)\n", |
104 | | - "* метод `late_fee(days_late)` – глобата за даден брой дни закъснение, съобразена с `MAX_FEE`\n", |
105 | | - "* `str(item)` → `\"[#<id>] <title> (<тип>)\"`, напр. `\"[#3] Dune (Book)\"` – **без** да се предефинира в наследниците\n", |
106 | | - "\n", |
107 | | - "**Наследници**\n", |
108 | | - "\n", |
109 | | - "| Клас | `loan_days` | `daily_fee` | `MAX_FEE` |\n", |
110 | | - "|---|---|---|---|\n", |
111 | | - "| `Book(title, author)` | 21 | 0.25 | 10 |\n", |
112 | | - "| `DVD(title, minutes)` | 7 | 1.0 | 20 |\n", |
113 | | - "| `Magazine(title, issue)` | 3 | 0.5 | без таван |\n", |
114 | | - "\n", |
115 | | - "**Клас `Library`**\n", |
116 | | - "* `add(item)`, `len(library)`, `item in library`, `for item in library` (всички обекти, в реда на добавяне)\n", |
117 | | - "* `available()` – **генератор** на обектите, които не са заети в момента\n", |
118 | | - "* `checkout(item_id, member, day)` – заема обекта. Връща `True` при успех и `False`, ако: няма такъв обект; той вече е зает; членът вече има 3 заети обекта; или членът дължи повече от 5 лв.\n", |
119 | | - "* `return_item(item_id, day)` – връща обекта и **връща глобата** (0, ако няма закъснение). Глобата се добавя към дълга на члена. Ако обектът не е бил зает – връща `None`.\n", |
120 | | - "* `pay(member, amount)` – намалява дълга на члена (не под 0)\n", |
121 | | - "* `loans_of(member)` – сортиран списък от заглавията, заети от члена\n", |
122 | | - "* `debtors()` – речник `член → дълг` само за членовете с дълг > 0" |
123 | | - ] |
124 | | - }, |
125 | | - { |
126 | | - "cell_type": "code", |
127 | | - "execution_count": null, |
128 | | - "metadata": {}, |
129 | | - "outputs": [], |
130 | | - "source": [ |
131 | | - "from abc import ABC, abstractmethod\n", |
132 | | - "\n", |
133 | | - "# your code here\n", |
134 | | - "\n", |
135 | | - "\n", |
136 | | - "# Tests:\n", |
137 | | - "\n", |
138 | | - "dune = Book(\"Dune\", \"Frank Herbert\")\n", |
139 | | - "matrix = DVD(\"The Matrix\", 136)\n", |
140 | | - "ng = Magazine(\"National Geographic\", 42)\n", |
141 | | - "hobbit = Book(\"The Hobbit\", \"J. R. R. Tolkien\")\n", |
142 | | - "alien = DVD(\"Alien\", 117)\n", |
143 | | - "\n", |
144 | | - "assert matrix.id == dune.id + 1 and ng.id == dune.id + 2 and alien.id == dune.id + 4, \"ids are shared by all item types\"\n", |
145 | | - "assert str(dune) == f\"[#{dune.id}] Dune (Book)\"\n", |
146 | | - "assert str(ng) == f\"[#{ng.id}] National Geographic (Magazine)\"\n", |
147 | | - "assert \"__str__\" not in vars(Book), \"implement __str__ only in Item\"\n", |
148 | | - "assert Item.__abstractmethods__ == frozenset({\"loan_days\", \"daily_fee\"})\n", |
149 | | - "\n", |
150 | | - "assert dune.late_fee(0) == 0 and dune.late_fee(4) == 1.0 and dune.late_fee(1000) == 10\n", |
151 | | - "assert matrix.late_fee(3) == 3.0 and matrix.late_fee(50) == 20\n", |
152 | | - "assert ng.late_fee(1000) == 500.0, \"magazines have no fee cap\"\n", |
153 | | - "\n", |
154 | | - "lib = Library()\n", |
155 | | - "for item in [dune, matrix, ng, hobbit]:\n", |
156 | | - " lib.add(item)\n", |
157 | | - "\n", |
158 | | - "assert len(lib) == 4 and dune in lib and alien not in lib\n", |
159 | | - "assert [i.title for i in lib] == [\"Dune\", \"The Matrix\", \"National Geographic\", \"The Hobbit\"]\n", |
160 | | - "\n", |
161 | | - "assert lib.checkout(dune.id, \"ana\", day=0)\n", |
162 | | - "assert not lib.checkout(dune.id, \"bob\", day=0), \"already loaned\"\n", |
163 | | - "assert not lib.checkout(alien.id, \"bob\", day=0), \"not in this library\"\n", |
164 | | - "assert lib.checkout(matrix.id, \"ana\", day=1)\n", |
165 | | - "assert lib.checkout(ng.id, \"ana\", day=1)\n", |
166 | | - "assert not lib.checkout(hobbit.id, \"ana\", day=2), \"ana already has 3 items\"\n", |
167 | | - "assert lib.loans_of(\"ana\") == [\"Dune\", \"National Geographic\", \"The Matrix\"]\n", |
168 | | - "assert lib.loans_of(\"bob\") == []\n", |
169 | | - "\n", |
170 | | - "available = lib.available()\n", |
171 | | - "assert next(available) is hobbit\n", |
172 | | - "assert [i.title for i in lib.available()] == [\"The Hobbit\"]\n", |
173 | | - "\n", |
174 | | - "assert lib.return_item(dune.id, day=21) == 0, \"returned on time\"\n", |
175 | | - "assert lib.return_item(dune.id, day=22) is None, \"not loaned anymore\"\n", |
176 | | - "assert lib.return_item(ng.id, day=10) == 3.0 # due on day 4, 6 days late\n", |
177 | | - "assert lib.return_item(matrix.id, day=12) == 4.0 # due on day 8, 4 days late\n", |
178 | | - "assert lib.debtors() == {\"ana\": 7.0}\n", |
179 | | - "\n", |
180 | | - "assert not lib.checkout(hobbit.id, \"ana\", day=12), \"ana owes more than 5\"\n", |
181 | | - "lib.pay(\"ana\", 2)\n", |
182 | | - "assert lib.checkout(hobbit.id, \"ana\", day=12), \"a debt of exactly 5 is fine\"\n", |
183 | | - "lib.pay(\"ana\", 100)\n", |
184 | | - "assert lib.debtors() == {}\n", |
185 | | - "\n", |
186 | | - "\"✅ All OK!\"" |
187 | | - ] |
188 | | - }, |
189 | | - { |
190 | | - "cell_type": "markdown", |
191 | | - "metadata": {}, |
192 | | - "source": [ |
193 | | - "## Задача 3 – `memoize` и `trace`\n", |
| 14 | + "## Задача 1 – `memoize`\n", |
194 | 15 | "\n", |
195 | 16 | "**`@memoize`**\n", |
196 | 17 | "* кешира резултатите на функцията по позиционните ѝ аргументи (приемаме, че са hashable)\n", |
197 | 18 | "* атрибути `hits` и `misses` на декорираната функция – колко пъти резултатът е взет от кеша и колко пъти е сметнат наново\n", |
198 | 19 | "* метод `cache_clear()`, който изчиства кеша и нулира броячите\n", |
199 | | - "* декорираната функция пази името си (`__name__`)\n", |
200 | | - "\n", |
201 | | - "**`@trace`**\n", |
202 | | - "* записва всяко извикване в атрибута `log` (списък от низове) на декорираната функция:\n", |
203 | | - " * при влизане: `\"<име>(<аргументи>)\"`, аргументите са с `repr` и разделени със `\", \"`, а keyword аргументите са като `key=value`\n", |
204 | | - " * при излизане: `\"-> <repr на резултата>\"`\n", |
205 | | - " * всеки ред е отместен с по 2 интервала за всяко ниво на вложеност (рекурсия)\n", |
206 | | - "\n", |
207 | | - "Например за\n", |
208 | | - "```python\n", |
209 | | - "@trace\n", |
210 | | - "def fib(n):\n", |
211 | | - " return n if n < 2 else fib(n - 1) + fib(n - 2)\n", |
212 | | - "\n", |
213 | | - "fib(3)\n", |
214 | | - "print(\"\\n\".join(fib.log))\n", |
215 | | - "```\n", |
216 | | - "```\n", |
217 | | - "fib(3)\n", |
218 | | - " fib(2)\n", |
219 | | - " fib(1)\n", |
220 | | - " -> 1\n", |
221 | | - " fib(0)\n", |
222 | | - " -> 0\n", |
223 | | - " -> 1\n", |
224 | | - " fib(1)\n", |
225 | | - " -> 1\n", |
226 | | - "-> 2\n", |
227 | | - "```\n", |
228 | | - "\n", |
229 | | - "Помислете какво става, когато комбинирате двата декоратора – има ли значение редът им?\n", |
230 | | - "\n", |
231 | | - "* Hint: `functools.wraps`" |
| 20 | + "* декорираната функция пази името си (`__name__`)\n" |
232 | 21 | ] |
233 | 22 | }, |
234 | 23 | { |
|
241 | 30 | " pass # your code here\n", |
242 | 31 | "\n", |
243 | 32 | "\n", |
244 | | - "def trace(func):\n", |
245 | | - " pass # your code here\n", |
246 | | - "\n", |
247 | | - "\n", |
248 | 33 | "# Tests:\n", |
249 | 34 | "\n", |
250 | | - "@trace\n", |
251 | | - "def fib(n):\n", |
252 | | - " return n if n < 2 else fib(n - 1) + fib(n - 2)\n", |
253 | | - "\n", |
254 | | - "assert fib(3) == 2\n", |
255 | | - "assert fib.log == [\"fib(3)\", \" fib(2)\", \" fib(1)\", \" -> 1\", \" fib(0)\", \" -> 0\", \" -> 1\", \" fib(1)\", \" -> 1\", \"-> 2\"]\n", |
256 | | - "assert fib.__name__ == \"fib\"\n", |
257 | | - "\n", |
258 | | - "@trace\n", |
259 | | - "def greet(name, punctuation=\"!\"):\n", |
260 | | - " return f\"Hi, {name}{punctuation}\"\n", |
261 | | - "\n", |
262 | | - "greet(\"Ana\", punctuation=\"?\")\n", |
263 | | - "assert greet.log == [\"greet('Ana', punctuation='?')\", \"-> 'Hi, Ana?'\"]\n", |
264 | | - "\n", |
265 | | - "\n", |
266 | 35 | "@memoize\n", |
267 | 36 | "def slow_fib(n):\n", |
268 | 37 | " return n if n < 2 else slow_fib(n - 1) + slow_fib(n - 2)\n", |
|
277 | 46 | "assert slow_fib.__name__ == \"slow_fib\"\n", |
278 | 47 | "\n", |
279 | 48 | "\n", |
280 | | - "# memoize outside: only the cache misses reach trace\n", |
281 | | - "@memoize\n", |
282 | | - "@trace\n", |
283 | | - "def fib_a(n):\n", |
284 | | - " return n if n < 2 else fib_a(n - 1) + fib_a(n - 2)\n", |
285 | | - "\n", |
286 | | - "# trace outside: every call is logged, even the cached ones\n", |
287 | | - "@trace\n", |
288 | | - "@memoize\n", |
289 | | - "def fib_b(n):\n", |
290 | | - " return n if n < 2 else fib_b(n - 1) + fib_b(n - 2)\n", |
291 | | - "\n", |
292 | | - "fib_a(10)\n", |
293 | | - "fib_b(10)\n", |
294 | | - "assert len(fib_a.log) == 2 * 11\n", |
295 | | - "assert len(fib_b.log) == 2 * 19\n", |
296 | | - "assert fib_a.log[-1] == fib_b.log[-1] == \"-> 55\"\n", |
297 | | - "\n", |
298 | 49 | "\"✅ All OK!\"" |
299 | 50 | ] |
300 | 51 | }, |
301 | 52 | { |
302 | 53 | "cell_type": "markdown", |
303 | 54 | "metadata": {}, |
304 | 55 | "source": [ |
305 | | - "## Задача 4 – Мързеливи заявки\n", |
| 56 | + "## Задача 2 – Мързеливи заявки\n", |
306 | 57 | "\n", |
307 | 58 | "Напишете клас `Query(iterable)`, с който да строим вериги от операции върху поредици:\n", |
308 | 59 | "\n", |
|
331 | 82 | "cell_type": "code", |
332 | 83 | "execution_count": null, |
333 | 84 | "metadata": {}, |
334 | | - "outputs": [], |
| 85 | + "outputs": [ |
| 86 | + { |
| 87 | + "ename": "AttributeError", |
| 88 | + "evalue": "'NoneType' object has no attribute 'to_list'", |
| 89 | + "output_type": "error", |
| 90 | + "traceback": [ |
| 91 | + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", |
| 92 | + "\u001b[31mAttributeError\u001b[39m Traceback (most recent call last)", |
| 93 | + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[3]\u001b[39m\u001b[32m, line 45\u001b[39m\n\u001b[32m 41\u001b[39m \n\u001b[32m 42\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m itertools\n\u001b[32m 43\u001b[39m \n\u001b[32m 44\u001b[39m \u001b[38;5;28;01massert\u001b[39;00m Query(range(\u001b[32m100\u001b[39m)).where(\u001b[38;5;28;01mlambda\u001b[39;00m x: x % \u001b[32m3\u001b[39m == \u001b[32m0\u001b[39m).select(\u001b[38;5;28;01mlambda\u001b[39;00m x: x * x).skip(\u001b[32m1\u001b[39m).take(\u001b[32m3\u001b[39m).to_list() == [\u001b[32m9\u001b[39m, \u001b[32m36\u001b[39m, \u001b[32m81\u001b[39m]\n\u001b[32m---> \u001b[39m\u001b[32m45\u001b[39m \u001b[38;5;28;01massert\u001b[39;00m Query([\u001b[32m3\u001b[39m, \u001b[32m1\u001b[39m, \u001b[32m3\u001b[39m, \u001b[32m2\u001b[39m, \u001b[32m1\u001b[39m]).distinct().to_list() == [\u001b[32m3\u001b[39m, \u001b[32m1\u001b[39m, \u001b[32m2\u001b[39m]\n\u001b[32m 46\u001b[39m \u001b[38;5;28;01massert\u001b[39;00m Query([\u001b[33m\"apple\"\u001b[39m, \u001b[33m\"Avocado\"\u001b[39m, \u001b[33m\"banana\"\u001b[39m, \u001b[33m\"Blueberry\"\u001b[39m, \u001b[33m\"cherry\"\u001b[39m]).distinct(key=\u001b[38;5;28;01mlambda\u001b[39;00m s: s[\u001b[32m0\u001b[39m].lower()).to_list() == [\u001b[33m\"apple\"\u001b[39m, \u001b[33m\"banana\"\u001b[39m, \u001b[33m\"cherry\"\u001b[39m]\n\u001b[32m 47\u001b[39m \u001b[38;5;28;01massert\u001b[39;00m Query(range(\u001b[32m7\u001b[39m)).chunk(\u001b[32m3\u001b[39m).to_list() == [[\u001b[32m0\u001b[39m, \u001b[32m1\u001b[39m, \u001b[32m2\u001b[39m], [\u001b[32m3\u001b[39m, \u001b[32m4\u001b[39m, \u001b[32m5\u001b[39m], [\u001b[32m6\u001b[39m]]\n\u001b[32m 48\u001b[39m \u001b[38;5;28;01massert\u001b[39;00m Query([[\u001b[32m1\u001b[39m, \u001b[32m2\u001b[39m], [], [\u001b[32m3\u001b[39m]]).flatten().to_list() == [\u001b[32m1\u001b[39m, \u001b[32m2\u001b[39m, \u001b[32m3\u001b[39m]\n", |
| 94 | + "\u001b[31mAttributeError\u001b[39m: 'NoneType' object has no attribute 'to_list'" |
| 95 | + ] |
| 96 | + } |
| 97 | + ], |
335 | 98 | "source": [ |
336 | 99 | "class Query:\n", |
337 | | - " pass # your code here\n", |
338 | | - "\n", |
339 | | - "\n", |
| 100 | + " pass\n", |
340 | 101 | "# Tests:\n", |
341 | 102 | "\n", |
342 | 103 | "import itertools\n", |
|
380 | 141 | "cell_type": "markdown", |
381 | 142 | "metadata": {}, |
382 | 143 | "source": [ |
383 | | - "## Задача 5 – Символни изрази\n", |
| 144 | + "## Задача 3 – Символни изрази\n", |
384 | 145 | "\n", |
385 | 146 | "Израз представяме като дърво:\n", |
386 | 147 | "* число (`int` или `float`)\n", |
|
468 | 229 | "cell_type": "markdown", |
469 | 230 | "metadata": {}, |
470 | 231 | "source": [ |
471 | | - "## Задача 6 – Отчет за продажби\n", |
| 232 | + "## Задача 4 – Отчет за продажби\n", |
472 | 233 | "\n", |
473 | 234 | "Дадени са поръчки като `namedtuple`-и `Order(customer, product, quantity, price, month)`.\n", |
474 | 235 | "\n", |
475 | 236 | "Напишете функциите **без нито един `for`/`while` цикъл** извън comprehensions – само с comprehensions, `map`, `filter`, `functools.reduce`, `sorted`, `zip`, `any`, `all`, `sum`, `max` и т.н.\n", |
476 | 237 | "\n", |
477 | | - "* `revenue_by_customer(orders)` – речник `клиент → общ приход` (`quantity * price`), **подреден** по приход низходящо\n", |
| 238 | + "* `revenue_by_customer(orders)` – речник `клиент → общ приход` (`quantity * price`)\n", |
478 | 239 | "* `top_products(orders, n)` – списък от `n` наредени двойки `(продукт, общо количество)` с най-голямо количество; при равенство – по име възходящо\n", |
479 | 240 | "* `loyal_customers(orders)` – сортиран списък от клиентите, които имат поръчка във **всеки** от месеците, които се срещат в данните\n", |
480 | 241 | "* `monthly_growth(orders)` – списък от тройки `(месец, приход, промяна)` по месеци възходящо, където `промяна` е процентната промяна спрямо предходния месец, закръглена до 1 знак (`None` за първия месец)\n", |
|
527 | 288 | "]\n", |
528 | 289 | "\n", |
529 | 290 | "assert revenue_by_customer(orders) == {\"ana\": 33.0, \"bob\": 30.0, \"cvetan\": 23.0}\n", |
530 | | - "assert list(revenue_by_customer(orders)) == [\"ana\", \"bob\", \"cvetan\"], \"the dict should be ordered by revenue\"\n", |
531 | 291 | "assert revenue_by_customer([]) == {}\n", |
532 | 292 | "\n", |
533 | 293 | "assert top_products(orders, 2) == [(\"tea\", 9), (\"coffee\", 7)]\n", |
|
550 | 310 | ], |
551 | 311 | "metadata": { |
552 | 312 | "kernelspec": { |
553 | | - "display_name": "Python 3", |
| 313 | + "display_name": ".venv (3.14.3)", |
554 | 314 | "language": "python", |
555 | 315 | "name": "python3" |
556 | 316 | }, |
|
564 | 324 | "name": "python", |
565 | 325 | "nbconvert_exporter": "python", |
566 | 326 | "pygments_lexer": "ipython3", |
567 | | - "version": "3.11.5" |
| 327 | + "version": "3.14.3" |
568 | 328 | } |
569 | 329 | }, |
570 | 330 | "nbformat": 4, |
|
0 commit comments