{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Удобные фильтры\n", "\n", "Короткие записи частых условий: isin — значение из списка, between — число в диапазоне, loc[маска, столбцы] — строки и столбцы разом, query — условие обычной строкой.\n", "\n", "Курс pandas · урок `pd-isin-query` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/pandas/isin-query).\n", "\n", "Выполняйте ячейки по порядку (Shift+Enter), начиная с первой — она готовит урок. После каждого упражнения идёт\n", "ячейка проверки: она печатает ✓ / ✗ и итог." ], "id": "intro" }, { "cell_type": "code", "metadata": { "cellView": "form", "jupyter": { "source_hidden": true } }, "source": [ "# @title Подготовка урока — выполните эту ячейку первой\n", "# Проверяет версии пакетов, записывает файлы данных в папку data/ и определяет _check — проверку упражнений.\n", "import base64, os, zlib\n", "\n", "for _name, _min in {\"numpy\":\"2.0\",\"pandas\":\"3.0\"}.items():\n", " try:\n", " _have = __import__(_name).__version__\n", " except ImportError:\n", " print(f\"Нет пакета {_name}: выполните %pip install {_name} и перезапустите ядро\")\n", " continue\n", " if tuple(int(x) for x in _have.split(\".\")[:2]) < tuple(int(x) for x in _min.split(\".\")):\n", " print(f\"Урок написан для {_name} {_min} и новее, у вас {_have}: выполните %pip install -U {_name} и перезапустите ядро\")\n", "\n", "_DATA = {\n", " \"shop_orders.csv\": \"\"\"\n", "eNrNvcuudclxHjjvp6gHOAQy8p5jPoghUIRbQLfkZlMDzapIAzJgArIGDQOCG4YvgHtioESpJKrIKr3CPm9krFzn3ztiX1bGbR31\n", "jKw6Fd/Oy4rMjIjviz/7xR///Bf/6k/++O2P/+iXP3/72Z//37/8s/9z/wc/+5Nf/sXbz/73P/rTP/35//H2sz/65c//9Z/94i/e\n", "/s0v/uyP//xnv3z7N7/4k5/9/O3/+vM/+tNf/skv/+J/gxACvMUQy08C/CTA20/DKG+X/3T58f2by/eX316+fbv84fLt+9eX7y/f\n", "vf/q8s+X31++u/zT+zdvl/9w+f79m8t379+8f/P+6+1P3v/92+VvLj++/9vLd5c/XH68/P7y/eXbr96/fv/1+19efrh8+/5XbymG\n", "8BYtqP/j8u3ln94u//X968u3l9++/9Xlh8uPl3/66v2by99efnz/+qsSvrr83Vus4Q0mTKQwZdzB/PP715ffXX5/+fHyD5fvLj9c\n", "fnf57u3yXy6/v3x7+fvt795/dfnd2+X/u/x4+X4O6dvL3391+bsN6v03l+8vv7v80xt0E9jHiP7H+1+/f3354f3fb6P5y+2ffQVh\n", "DiaVL/YTsR9D2ib828s/Xr69/PD+m7f3b7b/7P1X12V4u/zP9397+d3lx8s/X373/ldfxX122hAb/PiR/+3y+/dfX3748stK/rKa\n", "+WYovv005KKa5v94+W77ve9fv0X4YrlQy+nuJ560OytBhRS2X/vt5YfL9++/+snlP0+0796/vvzt+6/fv7783eNMMTZonUiNIrW6\n", "QHo+ldcF/5ttaO+/vvzh8rd4yesIb2ni9Rteevvp9h1e/p9tKj5gfnf5YQH1sGr/af5Hf3/59vL79998dfntV+//Dn8ul++2if1A\n", "HxS9FdVoP+b4P16+u/z+/a+ffzTjY4K3jYQhe+A5mv88B/jrbVzbav56/s23X13+cPnu8vcfGybm8DEwAIoyIm+bLj6B3XaktmN6\n", "u/y/lx8vv52j+N1c6K+38TD2xvY/vrr87eW7yz9+tS3R/By25fv26hzih3Nwg/2f79/Mv5gf4+XHn7x/s03i+zfvv/kKth/xd2+Q\n", "y8eH5wb61/P7+8f5F9t38AUpfvkQAPm+/PZTgPESibt2vA9hH2cm6JvDYThM9lcOhQ6uMTc9B2D//chBluN1Oj7IV9/wvhUbRUud\n", "7Y5ZG2IH6RSkJzpnktO1yQyyrgB52kQOtL79NMYmujY9Ob/nfomBmA3j/pR1cixRD8aao2S2z71YRqAgtfMWgnPn0dpe78u5h2K8\n", "mx9QXda2r+4vt3///ptt6X+8/Pb9m49p++4NrouhApOeHfuSJArVMuN6fIZ51lbdVzrffc4HtzGNT9PZX1z2YyFGIebVJY77LfCe\n", "WRGdPW0blPfhFhsBePz+LJdSMCNwXKDKPmtf7TOEjrb+9lMY4dXxL9y1auvM2d8d4CD2t0P1xcHMfgSAzK7y5EyBTkzNfgBJBsCP\n", "WiQQ2lyt4T4Vkc718kpovIcmV1DOsy+h82ZsYJJvbPVASPnOeFK+VwVvHjfM5TFhGiL55v9mCxBd/mF+9Wmbwz9cfv9WrpuwEAgo\n", "ZbG1GbfL/bdX+ttzsp3bYDbK+dAbnY3alFfi5c3SBCe86KfbYQRhe8VVEQzPmdkwOGszCEJM7ZwH3gTL4Q4ss5/r5OObw5u/5fuv\n", "5i/97ZyGH7eA7TbYN7iOzwAp3A8Z6Frdb7ubYYuv5KMsPvociSGA7rp9TRjKW1BOFO719dCacMlZuKtcQgu+qIxXaC50QssQ3DRe\n", "xhrsppfP23w70WDLX8Xq/BLUAgi2WCMID9+Og2tkI3DXtFODBfQGi9ogK3CTZeZNHntQlBwFtyvWs9WE8CryWwIxGlrn3ZKZGWat\n", "efbDe859gbvPVHvz5L0s3OAE26tEipmKMI76YpX2ASW6Sq9vG8ojmw8gfwzsAOjMjIfB2aeFAf91fkBbWcD3twffG9zMF2q+D+n1\n", "knEMG0DkG3l6lFIJIoz6atZMW5eNwjyASrszqLsAsp5mBR0eacMqziE3BcDC5Q5qMLQTrsdzbmqgSLUc1JL4vMYrEMjNsWjuxov4\n", "W3aEWiRTnFDYgb8a6ZrFLE+lv9x/1YggrJ0yIElPgX3zoVNsK9roTZBYZr2ka6YIJbDPyScR5FqotddFGsbjUQPE2bH7nFRiHO6D\n", "Y+LL9G610Z+srERjvnBqJ2iPN0arJ0Y+v2yeuLL3DS/nygd4uoH++za499+8/2r7v19tc7qdB5d/mKP6brvJ7zAtEJitrI6b+eOe\n", "IA053C17XYNv6rVFav/1c3vxMuMbYoczWiImH67h+rNln9pMzd9fwp3uAFoYbQClFYrXg3c5QKsE4cE96AMg+7I3upOiWz2RyTzn\n", "CGv97iMYyjpDxuaKPoCq4qKG/Gt7kp/RHXI9EKuQoqL2+WUKdC5QBwoBnxIid0K1vGp7JD+BeRlkvuF0xiVl8T3dbY3uW3mms79I\n", "ZvV8Ny2sYkJBQl8HwF3UQqdk4wicVzPdK0VbE0vcsnS++MrC045Opa5gEqy2YifmH5IK+jN1/zwHMR/BpWhqBDonRXZBe3VTHUDN\n", "Zq8yGL5hZqB7IL+61YxE+JTT3RF2dcUfiUBt/DmvIp99BjO1n+GcErjoCrbawIWuz5Lu50Ub3UdZ6ShLWz96WbOnsMvfZ+3OeHa8\n", "/uiMK5Mg4+bJYziMOagCvFbzyoybFZbzOBuDYEDOoroR/gPWBLS6qkIIxPohScJQOO+EpYhixIkMdEMUBYdOdAO0IAouuoBY9/uU\n", "ssoidHlmQIz5OGULuvuJtONkgiMj7jBf0YC49RsIpCwPVdZpqNJf+zp6obk+acyLnCUgEn6MrnX9zF11Gv7yCCwTv1N8azLk4PJQ\n", "HfG0qYZ9zgf5DQ95AG5QQmCIcWkDJFewWYsh6mqn//v2bV1+eP/Ln9w+szfo4wsM0B+dh4nok2Q2udlqQHIAczYOj0vfbxLpA8zR\n", "wGCnotYJO0D8/5iexcwdHxiA1AA2MGbxv2AwKvu8J7vVuOwgQLIGc1l4OTceQJ4AyNOrhBmWN0wtwuJCgsQMplnw5sQCkjaIMyM/\n", "zmf0+YEq78hIqyDmZ1xmxZNTaZRXygBInGAafx2Z1B7PSQbDDVloTK6oyoDkDeJWF9G6f2GoBUR5+NmHxcy3AlJVmEjR9+nANy9Y\n", "jkxsMrV7dIU3gMQWYn2WZ1DfxJvevHZXVQJ2SEB1PdYdgUWbr1FY3xQUIJmEuCUrodnFPQBpGGxG41Y9/EkH4vT7SIFgH9Rw5ysC\n", "UiSIjXm1V+48DZRBYA+QQkGcecMu3emLTecGwLqeIQ2EDW1z567EFA3A8XMFqQ7s81PP0DuabwmkPjB/e3eMonCUMsHxR7AjAkjE\n", "YOIp9TLZimtegCJCm/MoObUBgOQUYmflWo2pECR6EKd4Rj9LDsQEx9+Zt5MzbUmqWBxKNgAJG6Snwg1WAiVYUPiXZiMCN6WBdBMS\n", "sCucJUeSCeFFAQIgBYVp9BRJgx0pEaTHklBjLPAqXhCnpPT2VWiycbzApg6MV9YMV+mC3XhQlzUvH0fznLlKDXyMpZoCHvvH0O5G\n", "cJZIa/RBW+RHiuuYXl1wr2oBHwDrXJxW2xyuhP4PqAfRaPOhfqXfx11dPFqrQPgF0nBlyccPTfjqfOBqAdjiHHAl3X8gfGJe9mR8\n", "yTp6/Qj+1fAqFxCftxPgRDOmUy2Z7v82XKgpYLHNPH4KOn7Ss1J0tfnkZJ4fCCuVgMFRiY5R1x1Ko1g1sgR1DnkBAqOCTd7pCsSi\n", "IOfwaWxqPP7dr4y7Wco2pSGo4e4ne2rqND2CTrEQKtD5ycmPpTvdXUWuOnOCt/Yh6RFlXACo6EwoHHUU1xsNOP6ExQXUCUXlqGsm\n", "2I5EVKF5STi/FmJ1Kxpaxthl4ZGKzq+Nnxu6Q1LkMFftj3h8HaiN4i1XhnF7rp3aTCqpEcHuGgTPX7ZdicAopYcW7ta7nSRHER3R\n", "hKn+ho6/xlQJkayOwT5jN7dIrS9lzNnTwjbM9h4tUZPWKnXG3c8bkrfi+W7qklqAiodXKJ740STLhbdK4VL4vOiNFZv/Ecyba2sE\n", "bl1w5Po+dUNfFFc0dCL2J4V5TrVzfBj+a7UNYhO4/TrZPqsH+qODc9emOTMdCMiDroJVzQ96vBuFtnxGEJzoiS5NKvpX35Modc90\n", "zuR6bhxBCujlDiYpKmV4aaNeKdQAO/lBbPOVj+Ab4nxaM2fSkXtj0agVVw4DhiSh0TuFkSrNCUqz+83jWWTmX6V8ncyzZm0EgvXw\n", "blHkFhUmj1+g4+aap7r1JrV+Go1zRAoG6cQs9UgU7DVBTBaV4Nvlv3JGJja3RqLiGzX/UjEKQZNyCRZ6nTBurhQ02U/BtN28HyRz\n", "y4ZXLmN0isK410luwWMQ84evqX9ZqIVzigE5p0lWKmxda1agXQAgKC2KAYjVA59qYb7GEOmPXxYXKt4LMaTjsZgjDjEgV7WFfUN3\n", "vdUUIwb/ZVK8RnNI3IqhEIRNJ9wt+xRlALwrQQyVGmxRfhjZvhSHH8Da0G2itbv5S2dG7eAMSOY7PIZOd7vgTalLVMYw7kYaFNn2\n", "Y1J9BHQq1IXmoS9bPQLcQbdPrVTyw2ft3eIKyZPkixAJ3jpFxkwAREh0ICwOCls8SWBeEAqPkInVkKJ9NnbDhRqGdBpjSo0neHtH\n", "qNT+aOcI5u2DaXStXzcTUbN+ogyHl5GMgA6E5tjsdp+VQY3z0raaJ2eMgUKNbqZD8dlsMYIU3S1hlV3xlTVuMSIfrWDfsUc7D4SY\n", "CNgJDWj3Rc3HY5LL6sRYiMl1LvtFsDrGSn/bOu5hSBPtK9zuEJO/4IIFRBMOibHfLfHwCofswxl0uUfw7KrRtBDro2FsphNyqePZ\n", "N23YUvM7TkAAtki0W1JwLm+KBGDTRvfiXFW9fUbuL6ZELad+9vedMl3tM4QPYyp0WOAaSNWYF26oSgH8k207TLtbi1P7Otvhjq+Y\n", "qdPPfFsVg/TqYU4+pps/nKKkoZ9HUwd/QNbLJgcCKc5gai95GSiusmafr6oRcySIejco9FM50ZG24CX+sy9gpuZBWbMQEVV2quJy\n", "g2vKYBeiyk7d2uHUb0BumPedNGpV2GrlOEaO6Kq7TGVRqig8Of0RP3XKtIK+bcEyX4SYqhOrdl+lFwGAclfyAXjnyD4tyNcl9uNP\n", "8GRH7M6Y5Hm6F6nqiBicU0hTEwrnH36IirkPIjtX/tsQuC99xMnc1UeHslWA5LKKuJkTNAS3hiG7feT9skFkPCL+Is/QamHn6xJx\n", "FmN29jtz/IhhuOux9vN0deIZgKtg0gl4/ILbiDiVU+BxVGtLo+kWEa9xmq1jUeBhN6TdX4kCxGio2JI4DkTmm8CCsmO+90DcvqlP\n", "2UB5s+SVMCDa3Q43HKtW9gE1guBdi2vFOOamRkTpm/OzbpTkdvPf8QfF5z39+LdQo33ZjVQHppw5RPmLzzJ2tta/EXHv9i3nJuM7\n", "pwpx5KaMZgvGfCOiq02Z0eDRVFxgVeVxEd1tmm/ZTcd/nlWI3jZnuUZdS4yIyGML1VPX9Ceicc35Ge3ctA3iWU2VRuHDXji4QcEg\n", "+Sm7Zh8Avp9FZK8pNimiar/adTqjSn+KmGRztnL4TDmKdOZPeFJXcqW1pQ+lsubdlcYKI6mzvhLmPmBeN0Y0qiHGK3duR/KLVF7Z\n", "crthJluSGVPUGV99nZVORdReHS3U2HilqX38CrmT4wXvsg+YwKN2itXCGbrTO9Sg2yMGp9I/vmFdT+h4Ja2lD8k2J21HXoDYCZ3/\n", "1rxS6j4AcxPtiWWkaURiXyuVyd/kI9EBjXFOeVfUgwm3/Mh3e6K6hgOSEUPy+BmF7gbpqaqMf1lhF6nNUe92QWVTyZheodHffx8g\n", "tKfWRqdD6MOjKnNxlXMDZYcg3BCVL4KBTq+Z8oKTJJy2jzqFQNAeWmTLywQ1Jld7T2BTWm69/2Sg5gc4t9OzIwhuVilECuadBBcA\n", "HN/mU0CHY2b3HmIUHaSATquZ0Mlsh0utZZk1flI+hUKN8qQK1h/2/ovRgbNFUls6udlbCo0i5vAZ3bFS6AR264Fg30K75UEty+WG\n", "BfceP7QXVxAHAM53B8hTt2cNPq2NRpIFRbm1AShcjKcKxLngMW9ZyQuPlzFJEAlUCBZlkIOryHSCkAjYQwRKcbsBdBL0w5NAQ/xK\n", "UO7MS7sdvJz93Xyl5lvxDY0IAFh3p30V0cEynsURXXvpJugETq/ix3KXXmDcz29QvJQ8CDZgNr28QMdArD80dBQHG+bWijfHN9Wz\n", "oPtKqVsA+CqbKUaK8ro9rSFRJEDRFWEJABZXnZiIoYcMtzTPLzDIDqummKlNtWiGSO7rJNjjl04sBHMjy/u9r/cFup07U3As5nPb\n", "K+77tRFQUE+l6uETO0Uf1bnZXoqDTmrtnr1jUrq59KmrlrJnT+qUgJqH7tO+fvr1FInxxx3t8sCNLlBHji0lYjwsC1QZjo1vk3ND\n", "SshfzdYqYFYhFtiUvNpSIVYfhBRttXFW80sXmiq1n5vf22AfAHKX+TDFYofqBOqh3tdHAk8Ao3yLpEGnjFH2ffy950B/Ma9vJ9Oh\n", "Z6C/Nvpq4KQcqf3zdPOnj8+JzlUH9gfx2JpDYE11Shh+LKumPWXkM4ughF5GXkq5HMM4fbl8GP6pkiuxuWkx6vaL0Bo7HMY3KXtS\n", "ZOTYZwi+ntzXyA9RoMuXciegvLLso4iJyiD/gcA3L+uykfKgs/9Qa+CX3SmBQnVdMS5LfdALjBcpLUDBDqmtLhPqD3ugE5tKpLuP\n", "0SNj6WELOuQapwTJOTRcMsEPoq7nr3LgpdBBQdYVRfOlL1JBB0EXPOw577XSiG32PUHnHjodyGE2yfJOLoMC3ffYNt7e+OZlJ3NF\n", "Hm1wlPTMMdwKBPFRzc5WCp9qpCMqQSc2IjfErMVMNdEZgG4jmaWajw26dyhNtVDEUh0UiAX5jHrzT7tgjUa89cmdWmNX+ME1gvCQ\n", "pvKoDqj9bhTZs1GTq3nJmg8Cu8l4MS6VypueDkwSq2iBzuKS1u4YMW5AN6EyGcL5os6C4sUkWqTLyNV0ZC5kt2AoS43a7fSIwNbw\n", "VNWa6KD4eYCWif0gFXZjxzXa7bia4lWheVYeaKxr97MCShhfa5VCVPgU726AlXVAsSBxqTCpNYLxKFTnwOlRgrDTSQ0d80nWj5HX\n", "6SC1QRAUBaf8wZihBNUMPdCZy00U/lqNRWdedQLYRyIInnR0VcguvehXUWI3RMnFzw1UeYYg8vvU0fJV6QYtBO/7mt4V8eqnllpg\n", "VfTzVXWVAPwPGN17iqLntSmxZQXnXPoRsX9KdkFT1PgLwpWI8z/HFPPn9YOIrj9AFbJ3Q1c+lpH+wBRl6uHk5e4ULyVjV8Qss8oM\n", "yyGZgd0gnFYCZoRanZNIUWCKeoE3X5APwO6ULbCpTNAh2YMN4CFGpDgZkNLBVJbiXeklOWqkNrBLh4kvwqbTB2kETMWuxKswWA0K\n", "nTdbX5NYHYuWEDM/dkF8RxYXRvT8XeNrfAo5EpHZn8+cmdisReBnfBAhPrKahyhYXR4Yh6dFRgz2ifA6w8cOsAls6t4SGbHW43ii\n", "pKO+QmbEII8zTVhMD/ZjfqMD2nEOPyMe+1yJajvg9sm/+dIUHGRxBH4jI2p6Cocd1ZVXai3CYWQmI9L7ZpSpVCSLoGbEc58gBaxS\n", "99Vilv+wzogqPyHEGjGiUgA1nC5z4gfHT5RnxKlPcKhQai1pz4jyvkGFXGzVhxmRvudv78m/f7sFRPl8zIhhnqbs4HkNfdNZeOzg\n", "QEYU97ktXtfc26jjGRHfmcNUiFR4oShdCGLfz8kUlEsJD5ErTz5/aDqGczR/8wRrBCwEv0Svwb72obnvxk7nrwz1tl882vOV1/4x\n", "Om5/Vqb7uBLb8643VpwlGQQAmhxSvjLcd/MP55Jvdz81HEPlKV/55x+2o3MTl3ylkefnKoAO1WH5yu/OU5vrsKpDEAHi9vR2wOdn\n", "chzAlLe/MtELRReqJy+qDHKsxDy7SlsUmVKjyL3R/o2hsyLzWjCsmKs5osOgCLQvtTdMF7yXG7tYIAT65TkOirHs7yKS0l6dGykQ\n", "dM+GYVFvX6BNmhPQ+eO2q+S/nrQIjDLfnCKx7VCOsR5OoksCUVCnt/KWVuOCO0hCp86WGdqgTnphwll4/FhgKnfozn3NBQCWUE2q\n", "FCVkU4hWaJO/jRsxCf20TmXZAreIh6dOzD7e0t1q2JRQgjUe1P6RRK1ytjI6qtphg1wbI9gGdOTe59bNQK0ruQByL1LPQD/U/8kZ\n", "nZ6dc3q6SLBZYJlnTUbH6LBEMy39Vfx+BUOZI+dMwA5EVgSpKL5R5amZb6fm1FQL7URq57z25EoQgRsIW3k/pVn+vTM3OlWxmt6c\n", "+6bpxCbLlSqz8Boo/uPZZH3hJAdd2dQcvVXzQmB/BPNhXsLddKVzm2vPzVZuZ9sU4uN1bFRmC3Rgyr1dIgE7CActvEhJxJBPqcq+\n", "4pnOR4AzGHn7bCCfHk/sGwsOYJJ7pw6Kn4Aqldh3TNGAxbwkGFcanaJRLE/JqDR5XMNWOjWoll85biHqh6O86JRxh+9fcZhroBgh\n", "OTTXTkbLBoZnrkBhU/hEJrgXOk/bKFd0aiVWQM5ECcw1EbwjUo9ZhW/fQ5kOMOVPKsPYh1sI+kPLPJ+3dK10jF6lJpJvptGBFqsO\n", "bZNZlfvHHaDT7dhOuTkkPZSFw5Ar8v7ZkhbTDdgL3bIvW6A/ooJPW+D5dTcgxg+uJcoUc4v017sz2y0ISpfYEp201D4zV9vQcVB4\n", "DeWOi55aIQYh2NgQOpsc2mBulVqt0choAplVfqKCb1NZz90a3QXc0ittmUVDvr9a9jznnjXvdW1QxHFaLRu4wB1/ZD0Q86EMB4pF\n", "R957Y/jVFTmXe+UUG2bUgPRIbEr1oRg/vVpglG8dNzje0dMThQuyy8AyOq+zL5OsyD1TkJRPboeZe7kbVvu0PsI7PjoO+pMeF+ae\n", "O7k3gqANuTI3vQpMVgrZO8E4YC8z4wQdOfjxzMHbCkRHIOaPSxMM6rd5AAVKUsGXY4K3yr7lfTMixTto9u4Q2nVDY1wC7ViqAP+4\n", "+fBd9rQpCbZcfz4yBeSFywV3s1EIwEE5ofOl0BF46cFHpViv71w2TgAfRztpjW6Hh5yl+iadLeZ1gjt53M6hKZx5L51vv7aaYLi6\n", "nC4AgvfpGBRuhE/4ZIMPsvKNXEIgyGy1fcPpWQJQzE0PilEvdRwSKSFSq5A/scjZD11H0isBHaAzQ17PCKmXCZUJVKjMqIMlqF5C\n", "oaCJr0q4vvWUUKl1tUKaTGvWD5chmVJCI2DsZ7+u0MkOx9yT2QKmyxCUgA6m5C3/vi/WIAiPah6m3qZK8xanD4FOGZxK81XDya5A\n", "ahjdxa4A0GUbJ8NFCgdnEEgLpDuUaiL8Ci4/gE6yLSmWh0PN33QQUKjlBqemOgqSg5iKtMtmNOvgt8AmO1arsXkYWSpIOmJKya5L\n", "vQysDS807efYheiivi0F6VRMQUxB8wDOblJY1z3mCxKs2KGie1Rix0HeeMs4je6v4q8EMRAdlYhaz4U0M6bgaEvOskA7SqJjAnCu\n", "CBOiML0bkqeITV9Gd6yZ5IXCPwWcADlODUlsxPYZLCcLokXRqCAdjokL51ZXFCTEMT/cXqQFyIxTA8lY7IPqXkr7SW9e6sHRydfl\n", "oZmjr6nq7bPWYD7kkRDGZj+0cnIZjR+i7XxH6hlzYu/vEc4BEySoMeF4KupHdd8Ck6bgHJLOmOsF4cyyJzucQDq/IO2MOYV5KJuy\n", "J5k15osEaV9ESSde23qjo2YISkMEbXAKEpaYkstL4U8H7TM/UDYP2H2cjGg3UryYkIJ3pGgyB4XJSfA8YiEgOYpdljvY2mlHvVF2\n", "zrwgnYldZtghrIJkHXap7+jt54Uw7BsYEmrYFbcT272y6r4EAKq8H5JpmDLksTk/LPdBFDoIAU1dPm37utTjaXMNO+yIjSJymoKx\n", "b5RIpGDu3ODUAWTfA18cXdkFXrup0UvSm+TXOpSrDMEHwH03ozPy/ldhgA/MMtxLMMtVD2DH4FQKHS8u3yD/AL5qDXzYbNY40VVi\n", "oOzCszWf1UrKCrV6sVyZ/kWmcKty3mawBUm7XIn/H5PVqt9nPP3alaL/BaCcWEBwHpggxnrl9pcPzVxxV1vBS1MHpiu4L2UQMHa4\n", "QcPIKzVQsCXfnSMfMF+kFYhlDtdvdRrWePdjo4uM6T4RyBdnlwQi3//UTLDDdsk6Q65luopaKNj5inP7GOvdGINb9HN+NbUR+3pt\n", "U9k9oyLPUFRFC8yjvQ4CFDrYqLOlhbtf3o2aAfNnNqA/kyf6tMjaNfTd8+VRBbkaPoDlE2iJoDBqQy2RkX2RM4EMYyUMwU1mtHI3\n", "Y+3McFV0hWRf2xryWe0JV8wYM2iNmOeEJJYRoNapzXaqGvc+S4POUkjC2/MyNtoDQeD4Ptn335HXepZJMD+zeyQAEOEz6FSlI4+z\n", "yZ8mSV7zlTfuN5/CEwz1uorvS1UoegKrvlnplZh0l1gVAKju8HzzfGfbG53m1/FM3cZkm1fGLXsnAMALT+imXwW1yD70cWdU1reD\n", "scLj5lR3ec5PfsXPR+IA+iO6X2MKtW3ZA2BEihI8+xbvCIkiGOhohyK4DkCsZckEBXL12ne8RJAbvqxTnx+uyuGOQtBjKJa3B3vM\n", "laIKG67LbgY6MIHDRGfWM26R5i01IzKjE8NGvukRk7YMdKwklTDwUdS+hsA370v0cYE2nGQ1AME/W8qzhkjHm7qQ6HmQ7FIaFx2c\n", "NaDTZgbstFIPnEBIDZmgQYKTlfYsiJpraA2F4kHy3BCVGq+uz4EakGstyo/3OB1RQycQ5uJ20QvQHX0VMqlh0BllFJGuAj0am6Io\n", "SYVAZ4nXB/P4JaU0qtrGAHSCjloFGrkTDliyiG8FdCbUw7oc95ogM7ZgWhNBOjyV7PtdBaZThvAC49f5VMh01XJ1kqavUIhldrWz\n", "YB9YEQ6TbxUqNe9V5FancXSaNq2+6muVlXmcQicYRpJCkpk8DlBXQOdUX90mbLdwO5SlAL/GQOGbZxu3ZERg8CBqRKfYLEFP5pCT\n", "wEHFSNAPXvQ6pnaNiQ6PW8pjGpQSU5Dlt2KsyWY1Zopw9AL1i+XXeHP7U6AthVNE83as2xkwxb5qtVV/1tiIQUbu1+mJs3/KnQ4n\n", "F8+CUKV5RuVXjYNOWz2pkjA5gC03VQrUvldYaP74dPPWU1ysdL862f3XRwIQ2jiDkeQAs24jUFOiIBlOZJzviJkuT2qf2DmppkLH\n", "yxVpVIbXtHDMgFeq1PxovltkB0EOOz1zBs5T1incxrs4SR1ZjWe6DqdBAQWERhNDvGbkdbfi1t7tub0jR+yGZxw2kJ9xUB8n8c58\n", "q+xzJUdiEoJvI75kxJC1iag50Qk6Uqvw6ePmAskPNOdMp7JFJ1KCxTLz4MiFfpqvqT6ydBnfLq/3VM317jMDVTzwyYU6NzrJaRg2\n", "iyT+ntGBU7iqcgLzg5iPyaOFU0UMzKnmNvJyYZevAL5Nyasf8Tbn9Kbk8EuR15yR/XRG+/OkhVLtE0Tr3IDCpsDErrplZbMR+XIO\n", "JTZpH+/DowzxIaf5pCsW4neDqoggOafsLAaUB5hoK7S7PdflijjHS6UEUKp9qfG032yncIIUEm/37Y4NOfZ22OxE88rTWFdGABCb\n", "cwoPhmLJfAg+KUT2nGOMSZmglXxcjqAH0kpmGOFVG5Fc47M0mKeUbEWs1wm2RVWZO/9VvYXGpLLmD/Fm58q8phhLLmR8q+z3J+Lc\n", "TrkvUbpX9ElUAhTDcKuB3e03OpBljtbVpnab9LvZr66hQq15WZVwRQTgpbyjMce3sQEq4gdv+ldamhe7vroi6nB8lo012J8TiEi+\n", "Urkz5k4wICycqt0yK/SGGMpTHqkknwwCS/jCC12w4zIFbN2vPXlFdOWpYxWaubSBOY1mYGFlIKJJT8DX5FZNhACxpKd1qL7avPOO\n", "h2jTaWaXK2cncIJhTpZ5NX5OYLy7I+J9TzDIDgISAqvKn30lk9dddAvAVdexXrnkH/ZfdzVb+Hy+IVkk+cpF/7DLVdFh5qaunPMP\n", "8y1/hr6MBVbo7q7897pSbVvUKV6p7B+GSjota3gSnuwefuWp1103LBU7J0FhU/ijGwFgHj/K+M2VSv4xGhbN5nDJ2QaVl40rT/1j\n", "eqJY/4hziA7ks2eftXRy9wYLosWLDSCwUOFEjZt58xmRILIaKvI/z5HoePIJiXcPjOPCSgOCqd9xHZkuTs/yoS0v2KPcja4YiT28\n", "aiQrrORSOerdPMJ5YpF1NDqw4qC5NTP2AznzrQQg9dMoxvusDYJ3EJhj6D60EOivZ4RVBZFPgXkGL6EF5IfLIkXol9FwgF0MrkyU\n", "SFBi/Nx74An4AuHiFhKdYxhnKQMpoXTv2hYyBTvM/RmV8XzBVrcIFzRBeUULheApyCeGO6AD+nFgoYVKp/OM2mYLiNat6BF1Je8t\n", "oJN+q06o0e/xCUqAw+CMzqDg/OrEvOtzcwcYBGCto8CNtlksc9PADQKdHmH3idVNXmnf0grGOqTVOQNA92uLXmJhvP3mhs8fcaSI\n", "uZ+XBJu3QUCXlGfiqp4Vug0yAZOKcSxCAQ0KHct9Qs98xkA9nizZkwiQN96qNWCcX66VfIAZUbsGnaBAbiJpRKbInBXm1YEAg5iV\n", "8lkP47JK4+zMdouBzgmviEz1SUc4hpKdk3maRD5wPFGb8nPyyQIn//j20SUCFxL41QSDBcDyaImZYno3qmqx0EUS7ujVyRFvjn1q\n", "KI9o6d0VZSY5Z0VsxJri5BQcc7HTn57CWSXLKijJWz4OYv+hOk9bMtJSuDMcnIrG5wqkm1edWrwA5uohVsW9A7CJU9rSzRlDfFae\n", "4Y26T3ciqA99Mly/rpTpEPvnxV/BFV/5qEo3Vz7VRVtwu/zsW7je2T+J6KUCUoaaNFCLC25qdybBrltvM8qpUW2p3yHEkwp9WkJH\n", "Rz6hLaAdQLJZcyBgB2JXUvNJZl6aSplTlYFOlSYTfhwaNSAIH6w53i27WGSKz6xsOVEwRkmR7AKXMwXgdQjWBh0NkPx8U0YHVHmi\n", "zGVk0bRciX3IUUW9513ocqODsUoPi3wO8tWVXTynPCJ1YJKjJw+C8FBsaHyDlkDNZ/jcjixzFgvQWfS7HPJWsSDnuEVYITpUlbeS\n", "iNVDSQpFYkdn3vZQKplOVOmf912XQrHXPsXzJlOQ++ysVq2e9SOlEfTwUD7vrX7dSqfjHfUMBfOoh5K/A2cEpSB3Ojg9aTTk/lYD\n", "QdGzxGWP7Ap3g8unReBrpCNsWc442Q0lYkjaHUb0mzP9zXKhVf51qxY6rGV/PO5Fnm+Yf/esN+e2KdA+VI/61xvVRhBjOLVl6A7Z\n", "CWTY9Ilk+UeJAxh0RkNkKGcJdrLc/HJ+WqA2YZylodDazU9NwdgA58QgpsdvkYCFmv3qg3aAxAVQFXS2TCdLnCk8zgprzUvyIa0Q\n", "jDWtX+0dDUiWB4wBln3fb5VuszJ8agP2ASB/vOUiYtHxC1vrxBD0c7Wh1Hii7TsoRvUgHTfECd4FoZuDXp7AqjL0xgfgcB4Q33iz\n", "9pBhFolACqzxk6KIuTwXP4dPFLhuiGG8j+j8exKiGs8FLtG5VARRgueMtnCWnNs+hchvJnYRBz/zh8i6075JeXS9Op5okisnYvXu\n", "8s9wVsGSCU4gutUQjzhmS4ev47PVCqPc94hNPGFrPY9/qAQT5kYRUXmCwGnZMgMST+CvIQr0RBCHPY52nM64JCuB2MlTyFnAXLBF\n", "oA3A0t2W77Z0s0ryNUQ/3j1Bttx2EMF4F3+PfkpSDRGKp5pzaJbaj6Q1ycyjI5bylGwtxbk3X0O85Pg0DWcSsFGbNzxaO2Ivb5gx\n", "nMkzSRMRKGKsnpGSjji+UwU0Zp+rumROT/oJrCO/I+7vRO9mVsK+bMgTds4jRCoZ0xH9dOpMthPbYSnBdFo1HRFENzBxJkgks2VG\n", "Y/tDMxKj/Lwj4uhcKF5agl+n1BF1dB9E9wOIegDeLa8j9ujU50zZVku5KbB2xK3cFVj5ARlWIa4F4PEOJLCmSU13RMWcU/xaZdLz\n", "NeUHK3jgd0QCnaDrQJeZSpddcXW1aifiP9uviYBxKEur7G1H/Na4yqDrr6nZC0rgPhG1dsIB2KTpBAZlAYOOOLqbYGyEeHLjxX6l\n", "07YprHh0AFuKGaIPluBQvlJrP8Bq92T39ysLdjcPo7D0+3kpqYlw5cG2XcbvgTXnooDcrxzY5iMQx2x4aMFVvqym67kSZnfYMIZB\n", "HevIR9iBlE+FK4W27dJnrwNOAhd65ch+GN0IoWK6EO9md2XL7lDHQmKGM/TKcf3AEQi+8J7RfADpJ4v8aDnsvq1jlffYCQCzEzNb\n", "t6PHQe0LNQ0l19EUKBTwVS8EXoWPwn8aJ+Qgt1heC6IoF8MP7z89UhilMiPni0uJQj10yVCpXajNMt/HWvMWbaKeMgXl5i2ZyZd9\n", "5QvB4Dx6Ze/PVOkg7mtMtevd7n53O/uSnDodSHRU6t6XYhCAg3bTDgnrnpG3ak+6FPtqZvYMBC6cqBW/4yGP1p+VhTrFyufWyImA\n", "HVRtqo6vnIn5dXJFFvfKhU5Vypbk5Iz85UpNPkgaOQqHKsG4++jmZ6a8B4BrbBo8MATJdi8sZjPAnjuFExaaLpLgPQ9qfimZafSc\n", "yRVU+bYrN88NoO/nyNouVix2ymnObAGCdhSrNkoXOEAJQ9PldiBtoiUx5U9qTbavYyLoD1pOvnWSvWQ62GUI05pCLIUC2mtbjwM7\n", "/niyy2ipdD1DVEew1nOLjox02DZdlmAundqNnoVxdSIMguDRwk5Qv2FHVxIZekVem9VowRzmMiAKsyMVKJI8f6DK3tZIYe+v+Gds\n", "oIqcdlGdUbzg7jyfaiZgB/FE9a5kI6heSQrzq0tCLdTkkW6/tLBWaVz6tVS6hRqcWJ+kA+OnDmsj9tkhC059UEWH0Qzwtc9omNLr\n", "oLCvBZ8X8TC+IbmHn/6hBQKgKtxbPecMGGyOTW/oAGlPSvbsjq5FghBj920B2lu6G0I98XxP3oh85ZDeMoF9DB/4pL9buRsdnBoL\n", "bVU9meyjqyFf2VfcLr7CGVeQ1AFfuW/mxb8hbz7YAmvSXaMCsVwI2yCI7Evo67NjuvYe6EBa8bqYFaV59ve0A9w8+i4AMsw3vx6J\n", "ybWKmI+/64nAhtz9C1NmgL7fHOuumhHO79wAPsCc21y/OfSdFlxV8SdT9tbpN/BrN70BV7e1fjvGNvrwQw8I9t21N2ooVN93g86+\n", "Rua1906gHmkG6rDj7uluB8Ck6aWVuODx7EzvPwKxGaLbszyqzR/NwQA6BzWecLYP5P/LMz11KwlQjaB8m49E4MQ0ANttcCCvXz9F\n", "w24ep6MQWLYWv2AVK0X4FHbFQP5sez9APC8BOPodVvf1DoOYD6WdrWewjWqEQGDX1UN+q+eFbam79voNMqc6AtDF7umMis88oZB3\n", "7UbtrqWDLRMxEUQJyZ0jxmSx/+LdNwLyyhvhLQWjFtW+yjenu9FXIBWHFpe75ZuzTZPNkc6vpt+BGwFea0Gxvwi2YZ2r+eK8+wc/\n", "JZ5Z7DOuJNL+wbZpOuE3gSE+F2hc6Z39J+GpFpXtlTGuRMvdvr6iZB3DHlee4RLLWvY6rizDHeqw1aKiwn1caYAf9lPz6qgZHcwf\n", "VoGMKwXwY0ttRaaK9gD8COC4cgP7TpgaXf6J7cvaiCHGDcB6Vz4BUhR6GtDv5i55aMbspgcxfRAKYdSDCqwJj5uIXKBdhigqTR6q\n", "14yI3GhRKJzxHbYViRGINGPoMkwjRgqrDAXyuYEjomPCm0eyA2QCEDz7AIEM4LVrnS+BWO4MJZM4+FEdXfTB04lVj1gJMCT4FNbw\n", "iI0OeM0lsd0hYqfjVBd7vt44deIMihPFRZ2Le3VCzrorE8/LY94DRPLIScjFzldsOl1rZB5UKRJcSM2Gu3pcF1dQTSZ3pETQQxvn\n", "lnWPdPPJe9PgciLLb0csBHGt4KLfvfObT5WOkNeSy/KEcELkRU5SI2APteOGkj0/26wMykidwr3uUsPVMFSaFFya0u1EmfSddAbx\n", "feRAUCKXHK0M3mcgcMwyU0GkyAHgmHyrRGA+RnOkxu1VQnMv5UTNFr/q3nm4ZOTro6Oe0siFGA5QpL3zBOEyHRgnKpArnZ9uf7xn\n", "5EHzkyXVqMQIjFrKa0ZGvrNwmk1q7rJ5EBAjNbrLTMoIhqMgLzxfD8khaM43qrq7FyDmtaRIfszHCZDpiUskaMHJE2vNsu8lJd0B\n", "9LPqoX3gFquQ6R5eJiQ1jeNHQY6/eTT22aemEqshelaw7L+7EYQYs89VZEzjnU7KULaCkhtaF76NMujcWsNIx7uwBorWPNLizWiZ\n", "0VbJ4Yevdvp8CFfkmbfYAmRdNemokRpKp7c5GvXmwGbZtoDJrAy9GhC5Ii6jZoIBsZk7YMltsmpjarmzGn1z1PXmhWfResqKBkLH\n", "t+baCMRDdYJqstk22S+G2onJrcDT2MhEYNL0Xqg3bz9bkXV+rzl+L9rRAkGBXHUtoV/HD6IRhr/rPUBkwdcGFPF1ebslAMpHEXy/\n", "LRKjBxwkiWNr6W4JoiqawAtwNuSbJ01inNU9e7RyB1XP0Qfbx1UJ2GNXWk0qzWSUW6/RkAPfGlRFcCFxLnrfOMAy78StEyBGmYIL\n", "33c0dBaUw7eabnezzYsEc0YP1G4891nekZ+s7qX/AvOSyHqP1OqoKt1HXnarJwL2oG1qlQRVAhxet/gmRdOeqdURnTNZfABhdqCj\n", "o0ghMcAqiTdivHrp9krMHglMWcu7eqNQBU6VP5oJod4p5rJxpq9Mwwn4h4JAo6Njox/XCor3y9yGIxCACEVfqzl/8UAufIZagqIh\n", "AO8Sp4FalECPSEweCtxb9SbHuLndnRXTzDVrvK3czkA/ejvOaN7IFBD6WeL+SihWFGW3X4h9xW14QcOyA7AP/1Hv9sFJjU98gQR7\n", "oVHYEI3hxd3q7SBIs/Kh8wqNlPpRYwyK5xjOjA72j1YeQgjUOOPKyl9hlfnjbCeEAHcm4WQybPFHPfZjdQJGAhhg+CT6soPxY78F\n", "ISRi/tBFaiJtWgRVBRuEK/F2fPAbmT0xuLFbPQL/zQfhSvT9wDBJJr6+ZkK48n53oIdWz8YnWrJgrAtVIVxZvh8TdUQTdH5IgRe+\n", "6FUN4co8Hh9kWzgxI2pFNOSVIFy5yjsuQwlcXl3ihqIIB0O4Eqd3bInyAC8gC+HKnf6AyMPUOivKbHJrVCFceddjp7DGcNKzxgwl\n", "SbxBuJK8d7DQqhcJuzmY51NUtFDKcxwyAQMYn6Qv74TOvn9BobMak6cLiFoI7W6vFKqXzySin4F/fH8CdP5vabYt7mdrwQYWs7pn\n", "MQToFE/YDu/V0ao1q4oqQ4BB4A47m4rTO2bz61PV/PMFcxXRzWN21GymgLXSIP/MjkDN52btACqxqf2uFL96FVKJkZr0L0+EEBPF\n", "4Kn+8nbfDJjEfDeIfoZsKOihDvMbECI6URuHretCzzfhcl7TsRLz0ovx+oNr1D6Y+ojsO6lTk8viMO6lKQ5imNn6UPg4S8hpbt0t\n", "ISmyfOz6PB2eJNSXgNh/IEBrvHSKxOZn6IBCSMgDDk4RuJvAIoSUCfZDFw2bmDWEVKj9+yJNe4g03fwIBD0tSFLC5QbKvg6mRvAe\n", "qVVGBxH1IGvOq9ayYA90uhz59LYmVli+WAiEdDsdJmN7qWXhFVOqjuiq0jwIORD0A9lxkeyLxLDKp+fb4TRZ3qMbCRYSk8LvPkdi\n", "eLuNnBUNzYlCvW5vxT9i+DYXgZB8OwtnI8sQHbOTdgT2chYCYum+u3S8jlhHcoKuQLIgX64EOB5lRzXcYAgZHY6ZpcZk44U7IqqK\n", "AB3x1d0M9qXt5Gc8VBmZw+150HEKih1Z7qQEan98VnOufBI6705QgK6bkvCtTBYVdFqWZ+r3Fqc673sFHWj1SRRJmPEElc3VBty3\n", "QL6zKjnPlvrYWvvKTd0nYqGIR32tNJcVnX1VMLJUAnVCp08IBXnydqhMby4M0UAp8xWlEyhm8vmwPFhrlK3xA6EMOkGaOnhtwHh+\n", "rTXQH9DCqeSSOegKdFZHO7GFqjviv9BAeR9cjfz99C8EtkgJ10SNRqfQxZNshhOUMKRf0fnYnzXG0tca7190ubNfT6KSQ6iVQMVt\n", "KExdhycBx9qItTAMFCmtwWMqEYTa70x+kiNBx8R4olnpk/xpgaK8Vg9k3Z3mCdqA2NxcoulYBr1R5cWi3bzcFLhJ2bsIgI/Af4+0\n", "RGw+SK6YZNm15iXv5JYJwmNRuNFN6uyrLvWt0MnKfPkb3uOaD8Cs1Wk3xz5Fl/I4URl7X45GEWM1NW7gfX37WDtBlrSr48sGQWiD\n", "wLDVBC0OvQc6qbyrBues1lmWVAroEJiR6X47QKYgVT6RALbPF3LxWyi8B1EZKAchUYQCfsKk80TpyGE+jbz6ZZx0UJwrfy/EMrNr\n", "mOTc6pX+dmnXIe0lojeKW8CLBThjbL1T890uV721oKWrkbp3Ln7CDORKyrOqNQcOmxZDeSkdQOCMDoybpXRClY95OqARKfpwOhH2\n", "oSH3ucV4W1FfB7mhNx0kq1P7pnVOjKsk2leBZA8MybFgwOMKd27SxJ8wccVj4g63c6V7C9o5In/7RkZHz1OJJc1xbbDML4Uw2pdV\n", "JYxOwJhlm6xpGnQYChF39lcIAZ10nd3Vlf0B2uy/iCpDAGLUwpeXCPl5Ax95FQiRQD1KpXg+2g2ICsVCM9TKE0BI1P5o9vstICWI\n", "XfQrn9Pua99p6FAZz4SyjTfAOkEqBTHVjgl8TiOwHInDw/MRkGLBHEdPp3bT8wcUzd6gs3eOD5qbEOkVTKiT08nRgslfPCRnMKWt\n", "Yven+gASHUjMIO4iSg+IkJ/4MW7BvNjsS/YwItwnVjdKzxzQGeiHRzki5M8N18FaiS4wKQsKAGLUp6DqnKu7TwPiwE9gXbPbgwSy\n", "C4JwTJ06Ab9VYhsWfP4f5wqEqW0Enm3BswzAcov9Qkz/gtK8siTwhd39xXLKXs215vR8YXpv5uNh33ddzTd8oXl/AIQRBOV7h/Ep\n", "lenDXkwAX4jcHyYVjkh58/5Cuv4CDKeR1eELAXuDSs/iOpZ2bXrzwquOeRSy0/sLq3yD29IMEPz8VJIBGFLk8IXJ/oFyUEzr+vay\n", "w7KTmA5YugJRiIMAMyUo+Uelzv6xyAQkdHAVVkNNsUqPL46Ir+0+PEbsMQGBhOp2YPuYl7mlFClcH775kh0kUZCUHW5PVW9ZedVM\n", "mYAxuyKZuGyQCsWMvmIbkNAxWw97DjBKJwTWWG5x3zyN2ITWdbVXhyQLSJ2i8OrUud+0zfjq2Z7QwdHYBwfb0SY9hvIylgMB4zwa\n", "jxcgAzG47t74oqpYbohTDySwyryj50hXK+TzUrtKMNH8pDuE7qVYtZvPdPofGFyWO8M8pjLy4n3RbkEu56Y0z79y50rsS4qTHzPR\n", "AmvKO40O4HiGGzW5Zrb7dUgEyOj8GE+qmiT+IckMCgTnIQ9i9bEi3EW7HEq4g0mnZRR0UMryTOvAVteEAnTRvfawIDxRbkcFWBtx\n", "P3HkJRHzawEBxWXLCUNwGyqZIp7F10x6MP5RUgrdAbWbleQFNhcVQOV2cExJrIcKfE9SCZRG0AKvRS3vTbOvZScAMTZR5272G7UM\n", "Om0NvCIiycW87HOrgS7L9oZVt51b7l1XtFWuv95OAIi8jrGy1GRF/j0Z24rwgrI1EURGmyaXuKMbLOdYq5mClfEpQX07rPK6W8vd\n", "Lhrn+K1aKY5QvXJ1U6jIv2elTssyOmYA4Ye8a6cgvOTYsSsaxOT2BtcJ8gqduxFWR76FFgisVgmY4ywa0BEuFWx1ISsDjKq2t6GT\n", "pTAl11ReTwO0uFa2REwyA2T8xGFDjvppT3WjriC0QgEAnO8NfABOgKlVYk22V9az3ehv5aoLWrqYQUMeuB3e3CxVsm1QlOarLGbF\n", "EKRzeiAo25GvqzHm+XctnIAn0JHD7U/Io+ZvsEcCsPVnO6nBkw3qONOjMc26CM0McE/Ueqrm+uue70wGdWeCw3lBHnYoP+0FQiUI\n", "m+CI8OLBbM0LvRGkgw4gfMN9Gu50kkK0LC/ITMoeoH1QuzmJYu2MS/+4+bRdMKYYk7ADqMFh7g8GDma59YhGGM6ER4LA6CH6/x9I\n", "Zl56JIJ3qJJqp+R4oCnDUiNT6NbsLkpoWPXMGoXucq8m5LvxSo23xrs5cyqPRqM7mdd1avFwG51Odo7OGvFKBNXDdtxOjCmWJKxB\n", "WCyt1fjZ49CFImNAh+AWMU/p7HhRmrBwB9ulNAXLa9MBnp0AiSESrK0vg/45zQ39xoCOhqQKm77wGRbLlq5+MWSKC9EztW4xLzvh\n", "YigEKawVd013Ej88dhI8hkogD6Rauc9IjUmB040BHa+Zw3J0mKROIA8CHqz9y7Zm0WuKYXBhNNezCIGYZ1cq6m6xEdA5UDgtwuSV\n", "dRYM5kWrTZhIYDa1ZLeiQ1ACLM9G3Y8+9BOQ6HS3YO5BEiHTnxl8iVERCrH/oPYjLY8WGFReGxW/eD0Llc5yh/NquiMgf7+lUGrx\n", "bd4sALBd9AD5/a22uwe7Zo/AqOqwRZT2KQJmdCVzQRGBfRcWG6eLrkREbZ+YctfOjAhHxHKfykzCbreiGgIlmICUFRHxfSIolfn4\n", "hbkR8eJ3+R/Ql2McxcMj4sFPjaOa/RxLlAGIAu4R8dGn3eHb801ln5EMj4h3vhR24rKKI+Jgp6AsbTrUrXBBkF3gEP1616gJn6ge\n", "5IVu6PsXEZc6Ae/MPzp2msym5aBR/PKXu2/eThAJexo86udqq272hVrd/hHbO03B/OHKJo6Ijj3tJ90uNgUvEUs7wRPBMavikABA\n", "RmyKV643TCmgR6k0c0xFi8DfYJUAbN243ZIM8coE340fdq1ymCs/NPYG8IN8dXJfqeiw6xAVfqUdq+GbAMD2lbNhZOql8Up03w0/\n", "hNgku3YegVcy+4dBT7rrnPEre3wH2J6PwmyNcJteCd8fc791w5E8FjSqVmZQ/hjnd3KlnMMuP1Wbo2CoCWGRfzKaZc9PpjBeFe08\n", "J5MLRbfXrciiV7kS/IcLp4eOcsyNgsDnDXL/4pCLzYJuVIsTKA9idquQO0XwegaGSiBgD6WClgtPnwDI+c70RTmre3EskULJs/KS\n", "q7wbGjfvWxIBDLHrNFpiyXeGwJTiiDKbyoB7QR5tchbyaerB+4AqxXutK+VLr/UEXqZMSiNYm/zAmc1nXPCWC4e8cnumZK7eF/Nx\n", "WwY1n9ykdqLRPH/Za6AgpZ/YUjsZEYV37woEaZ1TYVFPjoVd/EClX9W8B9VIJ9e1E9I+PnT0dE57T9fLbM0Efd32QZWzrIWghGKs\n", "4OE+FGqloxOKAr165mjNcncE8uTDUhivvA644XPH2wneQXtpSdFNHXQUya/gO7Zw94tfxmn4G3aegO3m7KYCjuBzXFxMDZZ1vMTY\n", "IkF8VCw1PH92gESHJNRflRwDRij2LbXpwVjvifkubZnY3wLzTre46T7azdlPyZwc1YFk1mPRA08ZpXAc6svvthKIkIr8ZZpkhgy9\n", "KgQoqkdOa3TC7V2qjg6mdjuYNskixXPRlGaww7Mfdu12WE41mpbtB5rQML8yVWHzOLfXAzH4IDGjbnwZO9CfOpKliHZeEXokJjeJ\n", "antk9hViPQdxWbrRE12RcMabdp/OfIc0XB1WRyfEseaPmrOigeDHMwwDeHUS9UpMbhWtp2hKgh6MH5ztjc4PdIX6xrIAUIuyuFz0\n", "Tsw+lnWbCxn6oAihnBzJH4HO1HC73M7lHkDNt6j0hSamz0AeeXaa12bdX0U4RqIAKTGOWD6VaOQ789GP6a00znn2j0Itw2ntJJVQ\n", "AvZ3HJUgyDr+cE/X0QjIQ6WMdHMWvVFlwd3oFMy1iWM0IgjDoWPcfRn9RIXUbWwpIG9cV0VlprCDA5Qg6JACUDSuLjD72N9RIkF5\n", "FAl1lFxNIVEw+XNTODgznqFs23u0L/MfeYJlAqbN8ciuQikUOsRl7sqjQM8ZlfcxoqNsy8fU6iN4k0Ijhs8lgkQvxNWbLoVOQA6o\n", "vdL5GnQhUrZxITQGF0VTCdA5MZ6kJawvTgEAN9ORAIjJTQ/MFPHSGeQfJRCJ+bW/M383HoiHweAEiS5rgnNKB3ewTNdnqZhoyAnt\n", "gOVuQ5QTWZ874s1p72Ji0bPYJ0Ej5sWKokdRgAQ3BxpXXAluhlZpVJe5so1g3XUzwSD2171RVZyvFAOBeTjJXKJvahTZ8yxFuINx\n", "0O0TGubfIWKkG6iYM3Hs8FGKN1c8JcIgOWgrPmZvUswER3tt13WSS7EQdEldn6C+zgJj0Qyz4LLvTRGdMVtyJ2bTxs8ym0xHtltt\n", "d1aDq0x/ip3aB+B0l2JejXTGhe/KOAhIaLy2gfwWeCkFgsC8AwmHkYCC1Gh+HaRIpz8FURaHddAm5HKzsXkeXxYgpUxgGfdgVxGy\n", "hDjLTyXVXKbWhrHOUSZEjJ6L50lEmkcV4g5PgJzOy/LtgMjjbDHzeEpcuU2oQaBCbItgCSf7khAxdw4gNd84TzWCyDSQEqIBb4pa\n", "m0q+Q346Id7tFOoSl5AeR0G05mWvB0SKnXNThrWpT0IE2FhlrATt4WiA5N9SELU2NtaF28H/eoNyg6WIxzuF3A6ab1jLMBKi88bu\n", "3SY96hHUu1GFxr5RIfbxZj50vkYjL77HBxAdKoNYhQjKHcVacURvjs9i876094TIznPJITuKIoAFQUe9SojkPPeAOLm72sWI1DwB\n", "cjG+VIVWLelZxHneVQi7X5ZmfiuI8zyH4X0B2+cKufjxpPzXqF+fEOd32t+eR26veqPx1ZsBcYnjeMJCUTyEEcE3zTY5kfOL5U/D\n", "pgfjjGXeqBGrd5oPJ3WaAD2YMlWHCL1TbXC4uCW+VUs8AtGB50RZekwLcmUGWH6UABGR5wxC/iSiNbiic5KDbmCS29mVah13ebp0\n", "tqqoBZH/tLhyu3eQrQmiX5+iqEewFFinK8P7Y+Zi8SlQ3o03Op4YT5IS9EZ7FY64Erg/IB4C57avZ99m44YRn+UYbFIT0Q3jsDds\n", "ujLHd4gA6TN6gKcr+/sD9p6w7lreEfWIqqPjSjT/gGrxxKuSDkyyC6/07x3hWPzKXpvqAceMt7ZMobjygJJ0dit0fUr/RDmV1CpF\n", "V0WUVyNEDn3LIOZz6gJaJzCH/BBfWr0v9KHUe2qDQIWlnjLrxsK3yo8l9HBnM7vWy3ma551Jnoj8bhOpo4Mp+7THST0Smw88SnF9\n", "bk/E4EPnZms5SM/0B0M8tSPLjlk0Y9JmCHqlI6xVnI94eW4mPQD/XdUb3aenUOB3pE5H8poKw05QGkyyHGwfdC/xhAjVe8mOtswS\n", "6zCU15SBXG8R9D3VTqAWTz68eagPoHCNWVGj0QZXg/Gj/CMSBCZTV7s1EgF78NJsFyA2xK39Gejsqk8UO1y4czoQ1fNVB6V8vo5C\n", "wNYhQf8mKWlUOmDN9V5yWHjgWS4+o90tsLHA5OUX54Wjo8qn0Qk+5Oobbt5Bxh1IdFhM1reTQ6DfTu2OFchxIsDd16npw8YcDDpU\n", "Go8TcvhkERjU/uJEANZxD3PhbA6ZQg73gLAaQuAAcygUg7XW7ANMY36Ryc+h3q11ODkaYUHkXy36RGr0Q8nlPCKpEkwQJ8yhU4TX\n", "EneiLTvufrdjl+T5syHQ9U7tTG/SJiTcQY6zGvtloM54a+p6oggD+EOubwIZ0Hkwy/WKWwBmbkHIxD6nW+zxCQmF/uAUze3P5TY5\n", "bLQMlQ49JJ8kCks06DR0fvbS6ydwi+EyNIIniYVbnmIZOt0+MfiWWWZAfnwrIizDuyPY3LAxEJijymeh4hg4ml9Xa+QIdL4gKAPz\n", "NMWzjyIS2w/9qKTdBQUGdYG8HBOdjfsyeZ8Wf/OLj5lCyYUqdQG3HAsF9madgh6EnU/K8eYvp9b/EQGQG0FUGhX86Ebt1+SrgLgP\n", "ohOQk5iKyQeKIYqQ46Cz1pixfHlQaauDzinQQUE/R+wx6sGUH34CAqZvsyLckW64yutdinefNZz9tvdEfPJFpEQnFOIn3ZZ39Hy3\n", "nMFZF0GAYLlyp0K/PXWfL8lDJ6EjBk7lkTtAaTdII8ChjRN7ZuTUKZqGJ7yKDqZBp/LUFgjZFZG5OTfGY86BTqWGMCCJ4xrwGBVm\n", "OQOdQwGl75k15NMjq2epvUA850RAY3QSGs0509Eov9HFM9YJRXnu50LQGb17TG3lcq50tB3knZOyzBBXQDDnRk2O4fu0Mdo/jmPm\n", "To1HIYdBkB3LyO+mJ0lF19t/CQQMXsdSlffQAnQ0uXnrCO4wkY5jC4w7Fo/mkqh9RTncYWllLvluIYy6eytNt1yKC6BgYzshspv+\n", "5VLp3tNdJo78rQFBcisqjc5cTX6c91yQa8ucbnusZCbfqjLKXgYBgBS8p37uoRooTEuqMDg3UFGBTltpKjjWQ7BGghUDLLLYjASl\n", "2Oare1tNQkPck4JvWHnnE/9yRooEsZrnLuTdCSTfKyIcz9Y4IXlPS70DOFMfPXkhLi8GiGo8+8tIP1h2AAARjnktc9Q9n7ygjlvi\n", "ZcQ8niivu+w57G4fLK4XR4zn2Q+EI8TOL9JANONpvRXffV2MIJKbDaIWz55C27vKfvlA/N59/of8GSw0xElGIy7w3ibmNH54RpRg\n", "aKyEh0HdISMK8IYGR4lke2wekYFhVt/1M9yTE4oyUYbowBP9iHJvfSYh5u5cvRaM3+CcP0R13Ucw/PV7LCDsgxeRZ+f0RG+xFyXC\n", "yQMwSEZlxA2ey5KKX0UPoglPzxarc8094gnv7aiSvvGQ0KAyxoZYxjtA+QyFLgushnWYEfsYuqAhMGtXNWr79aNNEPBCjOBpNMYz\n", "ilMQi3a2MfKUjcwyAOZ1wfCL6fjnz0NE29mkSpPzmMuFWK3T0ACPuyhisu6DBeWu5XkvREGdPaB6OpFpgWicez+rcBZjVAllcW+I\n", "NjoRY3ertZ9fAaJoTvsaESLhu9QDUpI7RuzMGDT6xaucIqJfTgCGsMnS5LjbaM2SsjdYY33vBRE05/deTZ0X0zQJ1OS6zMApIwln\n", "oAucTEF8zriqJtX2jSiI0zk7kx1o4FvjXmYsXVa5IILnbJQWu0/NiMCw9nOS/vK1oy+IKzoXoQddUYbAkHbdKh396ya5fGfS6G/O\n", "cALHNBqR2OH+gpifs8djAKWqC79KVI0pchSDTt4pyktOSBxqZkFc1zlp6wJlNz2eHR8dY1HWDNSyVxAjdbaJTPApBfZ+uGyJoIK4\n", "sHszxXTWljUgaXdPptPZq+kYiiqb3EMZ8XHn9Hjno5oRRJCPKogEOydJUB0g+UrZKIJ6joIItXOKqiWsUhBNdrfWzgkkJD2Y6o6P\n", "2LkxHraqP04QCQzxQ4YFsW5nq8ye7FV5Kx0+L1Clr0P039nkNKYTiMaeSNxjA1GFY/LS4HqMMRTEGJ7L516uAY4ohrRSQXzluX4i\n", "+VHWrVGHoN34hYLJ6deWZtQO8Py7B6I1T6xujtMJTLK+oWZzDbo0vxmWf1tGROn5+WpCv5qsXUHc6d0LNsdWv8mCIDskEU96tmXm\n", "Zh/5H4kWgVsIUBALevbGLeWs7oXRAsfI16ptC7IXBVGoZxfkMpzDbYhEPQF6O0tWYJ+zTOFOoKlaMGTyNwVxp+OzgmULXSXqASRB\n", "N0SPnv2FY/i0GNV0nIglPfFH9K35LogYPdtAP7CyrE1+1QjKKxviRG9wEvUffruGgkjJEyVmP8dTZQDC3BbiO8/l4MliClymDuDw\n", "IolY1fsW0gmgPLlUIur07HYtCMjw6xQEKGwaT0Gs6TjlTeMpv1yPwrte8wEWmTfE494bALPeL5J9XSlAcO9YVxA/ekIoK2h4nl8H\n", "pgroIWp2fKbn53P9R6zs2Zw59BNzAHMKETWb163ZZ05PwV4+TxFNPA59jTJzZlVgvGrfgpjos4V0BL8Shf3XJ/rrt1ubrOM9P91t\n", "xxJcuBEFfnbH5l24lYUeiIw+wcBZBbQgavgOMD5LtL8gunh8VnKqzvSJDTOiHogovvcUN/YR0xhcfweD2hRKur5KISFy+ezJnLJL\n", "hGReWRCTPD0rBBbnGGcaFvG7p1U5L0l6HmUfWOVRgcjcKcg4xPxPALG75+g2GThL28nD5w4ieu9N4yuD3sK/jSHS9Zww7m1MGP3R\n", "wlie5cahsRJQiE4+t8JSjIPruvmGLU3EBTC63YV8O3yGjqYFUclvLYisnuCQLyYJNiJOegKVqOxh4BfxxeeP5jVsExBKC6KKzwF0\n", "/dGzfI4g3vfEGlUQ+331ANcZ5XGqCuKWz30qaEXE+xAQo3wCHAhduMVcow+wpV1AQdz2uWpbc23Fq+Q+PPi/AOwhIAI=\n", "\"\"\",\n", "}\n", "os.makedirs(\"data\", exist_ok=True)\n", "for _name, _packed in _DATA.items():\n", " with open(os.path.join(\"data\", _name), \"wb\") as _f:\n", " _f.write(zlib.decompress(base64.b64decode(_packed)))\n", "print(\"Файлы данных:\", \", \".join(sorted(_DATA)))\n", "\n", "# ─── Проверка упражнений: тот же раннер, что у задач на сайте ───\n", "# ─── Запуск тестов ───────────────────────────────────────────────────────────\n", "\n", "_TIMEOUT = 2.0 # секунд на тест; отдельный тест может задать свой: test_x.timeout = 10\n", "\n", "\n", "def _call_with_timeout(target, seconds: float) -> bool:\n", " \"\"\"Запускает target() в отдельном потоке. Возвращает False, если за seconds он не завершился.\"\"\"\n", " import sys\n", " import threading\n", "\n", " if sys.platform == \"emscripten\": # Python в браузере: потоков нет, таймаут обеспечивает страница\n", " target()\n", " return True\n", " # Большой стек нужен, чтобы глубокая рекурсия давала RecursionError, а не аварийное завершение Python.\n", " for megabytes in (256, 64, 0):\n", " try:\n", " threading.stack_size(megabytes * 1024 * 1024)\n", " worker = threading.Thread(target=target, daemon=True)\n", " worker.start()\n", " except (ValueError, RuntimeError, MemoryError):\n", " continue\n", " worker.join(seconds)\n", " return not worker.is_alive()\n", " target() # потоки недоступны — запускаем без таймаута\n", " return True\n", "\n", "\n", "def _test_info(fn) -> dict:\n", " \"\"\"Описание теста, его лимит времени и сообщение на случай зависания.\"\"\"\n", " limit = getattr(fn, \"timeout\", _TIMEOUT)\n", " hint = getattr(fn, \"timeout_hint\", \"\")\n", " message = (\n", " f\"тест не завершился за {limit:g} с — возможно, бесконечный цикл или рекурсия: \"\n", " \"проверьте, что границы/аргументы изменяются на каждом шаге\" + (f\". {hint}\" if hint else \"\")\n", " )\n", " return {\"title\": (fn.__doc__ or fn.__name__).strip(), \"timeout\": limit, \"timeout_message\": message}\n", "\n", "\n", "def _error_result(title: str, error: BaseException, user_file: str | None) -> dict:\n", " \"\"\"Результат упавшего теста: статус, сообщение, тип исключения и строка в коде решения.\"\"\"\n", " line = None\n", " if user_file: # самый глубокий кадр в коде решения; ошибка внутри самих тестов — без номера строки\n", " tb = error.__traceback__\n", " while tb is not None:\n", " if tb.tb_frame.f_code.co_filename == user_file:\n", " line = tb.tb_lineno\n", " tb = tb.tb_next\n", " status, message = \"error\", f\"{type(error).__name__}: {error}\"\n", " if isinstance(error, NotImplementedError):\n", " status, message, line = \"not_written\", \"функция ещё не написана\", None\n", " elif isinstance(error, AssertionError):\n", " status, message = \"failed\", str(error) or \"проверка не прошла\"\n", " elif isinstance(error, RecursionError):\n", " message = \"RecursionError: слишком глубокая рекурсия — проверьте базовый случай и то, что задача уменьшается\"\n", " elif isinstance(error, MemoryError) or (isinstance(error, OverflowError) and \"index-sized\" in str(error)):\n", " message = f\"{type(error).__name__}: не хватило памяти — возможно, создаётся слишком большая структура данных\"\n", " return {\"title\": title, \"status\": status, \"message\": message, \"error_type\": type(error).__name__, \"line\": line}\n", "\n", "\n", "def _run_tests(verbose: bool = True, on_start=None, on_result=None, user_file: str | None = None) -> list[dict]:\n", " \"\"\"Запускает тесты задачи (_TESTS — функции из tests.py) по порядку, каждый — с таймаутом.\n", "\n", " Возвращает список результатов: {\"title\", \"status\", \"message\", \"error_type\", \"line\"}, где status —\n", " passed · failed · error · not_written · timeout · not_run. Если тест завис, при verbose=True печатает\n", " итог и завершает процесс: зависший поток остановить нельзя. on_start(i) и on_result(i, результат)\n", " вызываются по мере выполнения; user_file — имя файла с кодом решения для номеров строк в ошибках.\n", " \"\"\"\n", " import os\n", " import sys\n", "\n", " if verbose:\n", " try: # ✓ и кириллица в консоли Windows со старой кодировкой\n", " sys.stdout.reconfigure(encoding=\"utf-8\")\n", " except Exception: # noqa: BLE001 — reconfigure может не быть (перенаправленный вывод, браузер)\n", " pass\n", "\n", " tests = list(_TESTS)\n", " results: list[dict] = []\n", " not_written = hung = False\n", " for index, fn in enumerate(tests):\n", " info = _test_info(fn)\n", " outcome: dict = {}\n", "\n", " def target(fn=fn, outcome=outcome):\n", " try:\n", " fn()\n", " except BaseException as e:\n", " outcome[\"error\"] = e\n", "\n", " if on_start:\n", " on_start(index)\n", " if not _call_with_timeout(target, info[\"timeout\"]):\n", " results.append({\"title\": info[\"title\"], \"status\": \"timeout\", \"message\": info[\"timeout_message\"], \"error_type\": None, \"line\": None})\n", " for other in tests[index + 1:]:\n", " results.append({\"title\": _test_info(other)[\"title\"], \"status\": \"not_run\", \"message\": \"не запускался: предыдущий тест завис\", \"error_type\": None, \"line\": None})\n", " hung = True\n", " break\n", " error = outcome.get(\"error\")\n", " if error is None:\n", " result = {\"title\": info[\"title\"], \"status\": \"passed\", \"message\": \"\", \"error_type\": None, \"line\": None}\n", " else:\n", " result = _error_result(info[\"title\"], error, user_file)\n", " not_written = not_written or result[\"status\"] == \"not_written\"\n", " results.append(result)\n", " if on_result:\n", " on_result(index, result)\n", "\n", " if not_written: # пока функция не написана, «даром» пройденные тесты не засчитываются\n", " for r in results:\n", " if r[\"status\"] == \"passed\":\n", " r.update(status=\"not_written\", message=\"не засчитан, пока функция не написана\")\n", " for r in results:\n", " if len(r[\"message\"]) > 300:\n", " r[\"message\"] = r[\"message\"][:300] + \"…\"\n", "\n", " if verbose:\n", " if not_written:\n", " print(\"Функция ещё не написана — замените raise NotImplementedError своим кодом.\\n\")\n", " for r in results:\n", " mark = {\"passed\": \"✓\", \"not_run\": \"–\"}.get(r[\"status\"], \"✗\")\n", " print(f\"{mark} {r['title']}\")\n", " if r[\"message\"]:\n", " print(f\" {r['message']}\")\n", " passed = sum(r[\"status\"] == \"passed\" for r in results)\n", " print(\"─\" * 40)\n", " print(f\"Прошло {passed} из {len(results)}\" + (\" — всё верно!\" if passed == len(results) else \"\"))\n", " if hung:\n", " print(\"Выполнение остановлено: один из тестов завис.\")\n", " sys.stdout.flush()\n", " os._exit(1)\n", " return results\n", "\n", "\n", "def _check(*tests, names=()):\n", " \"\"\"Запускает проверки упражнения и печатает ✓ / ✗ и итог — как на сайте.\"\"\"\n", " for name in names:\n", " if \".\" in name: # «Класс.метод» из заготовки: класс должен быть объявлен\n", " if not isinstance(globals().get(name.split(\".\")[0]), type):\n", " print(f\"✗ класс {name.split('.')[0]} не объявлен — выполните ячейку упражнения\")\n", " return\n", " continue\n", " if name not in globals():\n", " print(f\"✗ переменная {name} не создана — выполните ячейку упражнения\")\n", " return\n", " if globals()[name] is Ellipsis:\n", " print(f\"✗ {name} пока равна ... — замените многоточие своим кодом\")\n", " return\n", " globals()[\"_TESTS\"] = list(tests)\n", " _run_tests()" ], "execution_count": null, "outputs": [], "id": "setup" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Маски и операторы `&`, `|`, `~` позволяют записать любое условие. Но некоторые условия встречаются так часто,\n", "что для них есть короткие записи.\n", "\n", "## isin: значение из списка\n", "\n", "Нужны строки с кофе или чаем. Через `|` получается длинно:" ], "id": "text-10" }, { "cell_type": "code", "metadata": {}, "source": [ "# Два сравнения через «или»\n", "import pandas as pd\n", "\n", "orders = pd.read_csv(\"data/shop_orders.csv\")\n", "hot = orders[(orders[\"category\"] == \"Кофе\") | (orders[\"category\"] == \"Чай\")]\n", "len(hot)" ], "execution_count": null, "outputs": [], "id": "long" }, { "cell_type": "markdown", "metadata": {}, "source": [ "А если категорий пять? Метод `isin` («is in» — «входит в») проверяет, входит ли значение в список:" ], "id": "text-19" }, { "cell_type": "code", "metadata": {}, "source": [ "# То же самое короче\n", "hot = orders[orders[\"category\"].isin([\"Кофе\", \"Чай\"])]\n", "len(hot)" ], "execution_count": null, "outputs": [], "id": "isin" }, { "cell_type": "markdown", "metadata": {}, "source": [ "`isin` возвращает обычную маску, поэтому её можно перевернуть оператором `~` — «всё, кроме»:" ], "id": "text-23" }, { "cell_type": "code", "metadata": {}, "source": [ "# Всё, кроме кофе и чая\n", "other = orders[~orders[\"category\"].isin([\"Кофе\", \"Чай\"])]\n", "other[\"category\"].value_counts()" ], "execution_count": null, "outputs": [], "id": "not-isin" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 1. Три города\n", "\n", "Сохраните в `east` строки из Казани, Екатеринбурга и Новосибирска. В `n_capitals` сохраните, сколько строк\n", "приходится на все остальные города.\n", "\n", "
Подсказка 1\n", "\n", "`orders[\"city\"].isin([...])` — список из трёх названий.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "Остальные — та же маска с `~` перед ней; число строк — `len(...)` или сумма маски.\n", "\n", "
" ], "id": "east-task" }, { "cell_type": "code", "metadata": {}, "source": [ "east = ...\n", "n_capitals = ..." ], "execution_count": null, "outputs": [], "id": "east" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 1 — выполните после своего решения\n", "def test_east():\n", " \"east — строки из Казани, Екатеринбурга и Новосибирска\"\n", " assert isinstance(east, pd.DataFrame), f\"east — это {type(east).__name__}, а нужна таблица\"\n", " assert sorted(east[\"city\"].unique()) == [\"Екатеринбург\", \"Казань\", \"Новосибирск\"], f\"в east города {sorted(east['city'].unique())}, а нужны Екатеринбург, Казань, Новосибирск\"\n", " assert len(east) == 911, f\"в east {len(east)} строк — проверьте маску\"\n", "\n", "\n", "def test_capitals():\n", " \"n_capitals — сколько строк из остальных городов\"\n", " assert n_capitals != 911, \"911 — строки из трёх городов, а нужны все остальные: переверните маску\"\n", " assert n_capitals == 1537, f\"n_capitals = {n_capitals!r} — это не число строк из остальных городов\"\n", "\n", "_check(test_east, test_capitals, names=[\"east\",\"n_capitals\"])" ], "execution_count": null, "outputs": [], "id": "east-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "east = orders[orders[\"city\"].isin([\"Казань\", \"Екатеринбург\", \"Новосибирск\"])]\n", "n_capitals = len(orders[~orders[\"city\"].isin([\"Казань\", \"Екатеринбург\", \"Новосибирск\"])])\n", "```\n", "\n", "
" ], "id": "east-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## between: число в диапазоне\n", "\n", "«Цена от 320 до 390» — это два сравнения через `&`. Метод `between` («между») записывает их одним вызовом:" ], "id": "text-35" }, { "cell_type": "code", "metadata": {}, "source": [ "# Цены от 320 до 390\n", "middle = orders[orders[\"price\"].between(320, 390)]\n", "print(len(middle))\n", "print(sorted(middle[\"price\"].unique().tolist()))" ], "execution_count": null, "outputs": [], "id": "between" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Обе границы **входят**: товары ровно за 320 и ровно за 390 попали в выборку. Если границы нужно исключить, это\n", "задаёт параметр `inclusive`: `\"both\"` — входят обе (так по умолчанию), `\"neither\"` — ни одна, `\"left\"` или\n", "`\"right\"` — только левая или только правая." ], "id": "text-41" }, { "cell_type": "code", "metadata": {}, "source": [ "# Строго между 320 и 390\n", "strict = orders[orders[\"price\"].between(320, 390, inclusive=\"neither\")]\n", "print(sorted(strict[\"price\"].unique().tolist()))" ], "execution_count": null, "outputs": [], "id": "between-neither" }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Вопрос.** Что выведет `print(pd.Series([1, 5, 10]).between(1, 5).sum())`?\n", "\n", "- `0`\n", "- `1`\n", "- `2`\n", "\n", "
Ответ\n", "\n", "`2`\n", "\n", "По умолчанию обе границы входят: 1 и 5 подходят, 10 — нет. Маска `[True, True, False]`, её сумма — 2.\n", "\n", "
" ], "id": "quiz-48" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 2. Средний ценовой сегмент\n", "\n", "Сохраните в `mid_price` строки с ценой от 500 до 1000 включительно, а в `mid_share` — долю таких строк.\n", "\n", "
Подсказка 1\n", "\n", "`orders[\"price\"].between(500, 1000)` — маска.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "Доля — среднее маски.\n", "\n", "
" ], "id": "middle-task" }, { "cell_type": "code", "metadata": {}, "source": [ "mid_price = ...\n", "mid_share = ..." ], "execution_count": null, "outputs": [], "id": "middle" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 2 — выполните после своего решения\n", "def test_mid():\n", " \"mid_price — цена от 500 до 1000 включительно\"\n", " assert isinstance(mid_price, pd.DataFrame), f\"mid_price — это {type(mid_price).__name__}, а нужна таблица\"\n", " assert mid_price[\"price\"].min() >= 500 and mid_price[\"price\"].max() <= 1000, \"в mid_price есть цены за пределами 500–1000\"\n", " assert len(mid_price) == 858, f\"в mid_price {len(mid_price)} строк — проверьте условие: обе границы включаются\"\n", "\n", "\n", "def test_share():\n", " \"mid_share — доля таких строк\"\n", " assert mid_share != 858, \"858 — число строк, а доля — среднее маски\"\n", " assert abs(mid_share - 858 / 2448) < 1e-9, f\"mid_share = {mid_share!r} — это не доля строк с ценой от 500 до 1000\"\n", "\n", "_check(test_mid, test_share, names=[\"mid_price\",\"mid_share\"])" ], "execution_count": null, "outputs": [], "id": "middle-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "mid_price = orders[orders[\"price\"].between(500, 1000)]\n", "mid_share = orders[\"price\"].between(500, 1000).mean()\n", "```\n", "\n", "
" ], "id": "middle-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## loc: строки по маске и столбцы разом\n", "\n", "`loc` из позапрошлого урока принимает на месте строк не только метки, но и маску. Тогда одной записью\n", "выбираются и строки, и столбцы:" ], "id": "text-64" }, { "cell_type": "code", "metadata": {}, "source": [ "# Кто купил 9 штук и больше\n", "orders.loc[orders[\"quantity\"] >= 9, [\"date\", \"city\", \"product\", \"quantity\"]]" ], "execution_count": null, "outputs": [], "id": "loc-mask" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Если на месте столбцов одно название без списка, получается Series — по нему сразу можно считать:" ], "id": "text-71" }, { "cell_type": "code", "metadata": {}, "source": [ "# Средняя цена покупок в Казани\n", "print(orders.loc[orders[\"city\"] == \"Казань\", \"price\"].mean())" ], "execution_count": null, "outputs": [], "id": "loc-series" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Читается как фраза: «из `orders` взять строки, где город — Казань, столбец `price`, посчитать среднее»." ], "id": "text-75" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 3. Дорогие покупки в Казани\n", "\n", "Сохраните в `luxury` покупки в Казани с ценой выше 2000 — только столбцы `date`, `product`, `price`.\n", "В `luxury_avg` сохраните среднюю цену в этих строках.\n", "\n", "
Подсказка 1\n", "\n", "`orders.loc[(условие) & (условие), [\"date\", \"product\", \"price\"]]`.\n", "\n", "
" ], "id": "luxury-task" }, { "cell_type": "code", "metadata": {}, "source": [ "luxury = ...\n", "luxury_avg = ..." ], "execution_count": null, "outputs": [], "id": "luxury" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 3 — выполните после своего решения\n", "def test_luxury():\n", " \"luxury — дорогие покупки в Казани, три столбца\"\n", " assert isinstance(luxury, pd.DataFrame), f\"luxury — это {type(luxury).__name__}, а нужна таблица\"\n", " assert list(luxury.columns) == [\"date\", \"product\", \"price\"], f\"столбцы сейчас {list(luxury.columns)}, а нужны date, product, price\"\n", " assert luxury[\"price\"].min() > 2000, \"в luxury есть цена не выше 2000\"\n", " assert len(luxury) == 12, f\"в luxury {len(luxury)} строк — проверьте оба условия\"\n", "\n", "\n", "def test_avg():\n", " \"luxury_avg — средняя цена таких покупок\"\n", " assert abs(luxury_avg - 2666.6667) < 1e-3, f\"luxury_avg = {luxury_avg!r} — это не средняя цена дорогих покупок в Казани\"\n", "\n", "_check(test_luxury, test_avg, names=[\"luxury\",\"luxury_avg\"])" ], "execution_count": null, "outputs": [], "id": "luxury-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "luxury = orders.loc[(orders[\"city\"] == \"Казань\") & (orders[\"price\"] > 2000), [\"date\", \"product\", \"price\"]]\n", "luxury_avg = luxury[\"price\"].mean()\n", "```\n", "\n", "
" ], "id": "luxury-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## query: условие строкой\n", "\n", "Метод `query` («запрос») принимает условие как текст. Внутри текста названия столбцов пишут без кавычек и без\n", "`orders[...]`, а условия соединяют привычными `and`, `or`, `not`:" ], "id": "text-84" }, { "cell_type": "code", "metadata": {}, "source": [ "# Условие в виде строки\n", "orders.query(\"price > 3000 and city == 'Новосибирск'\")" ], "execution_count": null, "outputs": [], "id": "query" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Сравните с `orders[(orders[\"price\"] > 3000) & (orders[\"city\"] == \"Новосибирск\")]` — результат тот же, а читать\n", "легче. Текстовые значения внутри условия берут в кавычки другого вида: снаружи двойные — внутри одинарные.\n", "\n", "Переменные Python в условии отмечают знаком `@`; список проверяют словом `in`:" ], "id": "text-91" }, { "cell_type": "code", "metadata": {}, "source": [ "# Переменные в запросе\n", "limit = 3000\n", "towns = [\"Казань\", \"Новосибирск\"]\n", "len(orders.query(\"price > @limit and city in @towns\"))" ], "execution_count": null, "outputs": [], "id": "query-var" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Если забыть кавычки вокруг текста, `query` примет слово за название столбца или переменной:" ], "id": "text-98" }, { "cell_type": "code", "metadata": {}, "source": [ "# Казань без кавычек\n", "# Эта ячейка показывает ошибку UndefinedVariableError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n", "try:\n", " orders.query(\"city == Казань\")\n", "except Exception as error:\n", " print(f\"{type(error).__name__}: {error}\")" ], "execution_count": null, "outputs": [], "id": "query-error" }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Типичная ошибка: name 'Казань' is not defined.**\n", ">\n", "> В `query` слово без кавычек — это название столбца. Текстовое значение пишут в кавычках:\n", "> `\"city == 'Казань'\"`. А название столбца с пробелом внутри берут в обратные кавычки: `` `unit price` > 5 ``." ], "id": "component-103" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 4. Дорого и много\n", "\n", "В переменной `min_price` — порог цены. Сохраните в `bulk` строки, где цена строго больше `min_price` и количество\n", "не меньше 3. Используйте `query`.\n", "\n", "
Подсказка 1\n", "\n", "Переменная Python внутри запроса — со знаком `@`: `price > @min_price`.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "Два условия в `query` соединяет слово `and`.\n", "\n", "
" ], "id": "bulk-task" }, { "cell_type": "code", "metadata": {}, "source": [ "min_price = 1000\n", "bulk = ..." ], "execution_count": null, "outputs": [], "id": "bulk" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 4 — выполните после своего решения\n", "def test_bulk():\n", " \"bulk — дороже min_price и не меньше 3 штук\"\n", " assert isinstance(bulk, pd.DataFrame), f\"bulk — это {type(bulk).__name__}, а нужна таблица\"\n", " assert len(bulk) > 0, \"в bulk нет строк: проверьте условия\"\n", " assert bulk[\"price\"].min() > 1000, \"в bulk есть цена не выше 1000: сравнивайте с переменной min_price\"\n", " assert bulk[\"quantity\"].min() >= 3, \"в bulk есть строки, где меньше 3 штук: оба условия нужны сразу\"\n", " assert len(bulk) == 54, f\"в bulk {len(bulk)} строк — проверьте оба условия\"\n", "\n", "_check(test_bulk, names=[\"bulk\"])" ], "execution_count": null, "outputs": [], "id": "bulk-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "min_price = 1000\n", "bulk = orders.query(\"price > @min_price and quantity >= 3\")\n", "```\n", "\n", "
" ], "id": "bulk-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Что выбрать — маски или `query`? Результат одинаковый. `query` короче и читается легче, когда условий\n", "несколько. Маски нужны, когда условие собирается по частям, переиспользуется или по нему считают (`sum`,\n", "`mean`). В этом курсе встречаются оба способа.\n", "\n", "## Итоги\n", "\n", "- `столбец.isin([...])` — значение входит в список; с `~` — не входит.\n", "- `столбец.between(a, b)` — от `a` до `b`, обе границы входят; `inclusive=` это меняет.\n", "- `таблица.loc[маска, столбцы]` — строки по условию и нужные столбцы одной записью.\n", "- `таблица.query(\"условие\")` — условие строкой: столбцы без кавычек, `and`/`or`/`not`, переменные через `@`." ], "id": "text-115" }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Подробнее в справочнике:** [pandas/filtering](https://ds-edu-trainer.vercel.app/reference/pandas/filtering) · [pandas/loc-iloc](https://ds-edu-trainer.vercel.app/reference/pandas/loc-iloc)" ], "id": "more" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python" }, "colab": { "provenance": [] } }, "nbformat": 4, "nbformat_minor": 5 }