├── 10. Dictionaries.ipynb ├── 11.Python_Functions.ipynb ├── 12.OOPs (Object Oriented Programming) - Jupyter Notebook.pdf ├── 13. Lambda functions - Jupyter Notebook.pdf ├── 14. Regular Expression [RegEx] - Part 1 - Jupyter Notebook.pdf ├── 15. RegEx - part 2 - Jupyter Notebook.pdf ├── 16 . Numpy - Jupyter Notebook.pdf ├── 17. Pandas_Part 1 - Jupyter Notebook.pdf ├── 18. Pandas Part 2.pdf ├── 19. Cars Exploratory Data Analysis.ipynb ├── 2.Python Operators .ipynb ├── 3. Data Types.ipynb ├── 4. Type Conversion and Type Casting.ipynb ├── 5 . if-else-elif-nested loops.ipynb ├── 5. For-Nested Loops.ipynb ├── 6. While_loops.ipynb ├── 7. Python Lists.ipynb ├── 8.Python Tuples.ipynb ├── 9. Python_Sets .ipynb ├── Day 1. Python introduction and Variables.ipynb └── README.md /10. Dictionaries.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### Dictionaries are unordered collections of unique values stored in (Key-Value) pairs.\n", 8 | "\n", 9 | "Python dictionary represents a mapping between a key and a value. In simple terms, a Python dictionary can store pairs of keys and values. Each key is linked to a specific value. Once stored in a dictionary, you can later obtain the value using just the key.\n", 10 | "\n" 11 | ] 12 | }, 13 | { 14 | "cell_type": "code", 15 | "execution_count": 23, 16 | "metadata": {}, 17 | "outputs": [ 18 | { 19 | "data": { 20 | "image/jpeg": "/9j/4AAQSkZJRgABAQEAYABgAAD/4SU0RXhpZgAATU0AKgAAAAgABgALAAIAAAAmAAAIYgESAAMAAAABAAEAAAExAAIAAAAmAAAIiAEyAAIAAAAUAAAIrodpAAQAAAABAAAIwuocAAcAAAgMAAAAVgAAEUYc6gAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFdpbmRvd3MgUGhvdG8gRWRpdG9yIDEwLjAuMTAwMTEuMTYzODQAV2luZG93cyBQaG90byBFZGl0b3IgMTAuMC4xMDAxMS4xNjM4NAAyMDIxOjA4OjIzIDE5OjIwOjE3AAAGkAMAAgAAABQAABEckAQAAgAAABQAABEwkpEAAgAAAAMwMAAAkpIAAgAAAAMwMAAAoAEAAwAAAAEAAQAA6hwABwAACAwAAAkQAAAAABzqAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMjAyMTowODoyMyAxOToxNjo1MgAyMDIxOjA4OjIzIDE5OjE2OjUyAAAAAAYBAwADAAAAAQAGAAABGgAFAAAAAQAAEZQBGwAFAAAAAQAAEZwBKAADAAAAAQACAAACAQAEAAAAAQAAEaQCAgAEAAAAAQAAE4cAAAAAAAAAYAAAAAEAAABgAAAAAf/Y/9sAQwAIBgYHBgUIBwcHCQkICgwUDQwLCwwZEhMPFB0aHx4dGhwcICQuJyAiLCMcHCg3KSwwMTQ0NB8nOT04MjwuMzQy/9sAQwEJCQkMCwwYDQ0YMiEcITIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIy/8AAEQgAfQEAAwEhAAIRAQMRAf/EAB8AAAEFAQEBAQEBAAAAAAAAAAABAgMEBQYHCAkKC//EALUQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+v/EAB8BAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYHCAkKC//EALURAAIBAgQEAwQHBQQEAAECdwABAgMRBAUhMQYSQVEHYXETIjKBCBRCkaGxwQkjM1LwFWJy0QoWJDThJfEXGBkaJicoKSo1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoKDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uLj5OXm5+jp6vLz9PX29/j5+v/aAAwDAQACEQMRAD8A9/ooAKKACigAooAKKACigAooAKKACigAooAKKACigAooAKKACigAooAKKACigAooAKZ5sZlMQkXzANxTPIHrigaTew+igQVVv9RtNLtTc3s6wwggbm9T0GB1pN21KhCU5KMVdslS4ie2W4DgRMoYM3HB+vSpQQRkHINMTi1uFNSRJN2x1badp2nOD6UBZjqKBBTXkSNd0jqi+rHAoBJvRCPLHGVDyKpc4UMcbj6Cn0Ds9xqSJKu6N1dfVTkU6gGmtGJkZxmqf9rWP9qnTPPAvAu/yiCCRjPB6H8KTaRUKcp35Vsr/Iu0UyAooAKKACigAooAKKAMjxPq8miaFPeworzAqkYf7u5iBz7VhaUl7H8SJlv54pphpQ+eKMoCPMHbJ5zms5N8yR6eGpwWHnN7tS/C3+Z2lcnF4pvJNRS3P9jbWlCHbqAL4zjhcdfaqlKxz4XDxqqXNfTsr/f2Osrk/Gk77tLtfJdYnvYnN033EIbgHHOT+VE/hDBK9eP9fL5m/q+nLq2k3Ng7mNZ02FwM496r6xdjSdHUreRWpBWJJJIWlz2wEUgk+goempFJufLStfX87f5Gf4V1261W51Kzu9rvZOm2YQtEXVwSMo3IPFauk6VHpQvRHIX+1Xcl02RjBfHH6Uo+8kzXEpUJzpR2dn+F/nuJavqp1e8W6ht109Qv2Z0J3se+6udubOW0+IukSve3E/2kXDbJG+WNQnCqB2GaUr217mmHlTjOUYK94Pfo+W7t8zs6z9a0pNZ01rOSQxqZEfcBn7rA/wBMVbV1Y4qVR06kZro7mH4x846j4eFsUExvvkMgJUHb1IHWr3h7VL27utTsL8xST2EwTzYl2h1YZBxk4NQm1I7pQhLCRf2kr/Lmt+pe0TSk0XS0sY5DIqO7biMfeYt/XFJpz6q9xfDUYreOES4tTExJZPVvfp+tUk1ZI5ZzhVc6k93qvv1/A5n+zbSDxlYQaL532i3ZpdRmMrONhHCsSeWJ7fjVrxFO9p4v0K4iha6kCTILePO/BAy3pge5FRsnbuejzOpVgqjs3B38rp2/Cx1tFanjBRQAUUAFFABRQAUUAU9V0y31jTZrG6DeVKBkqcEEHII98iqWm+G7bTtTbURdXdxdNB5DPcSbsrkH09hUuKbudNPFThSdJJWf362/yRs1WGnWIkDiztw4OQwiXOfXpTsmYRnKPwuxZrI8R6Vcavp8UVrJEk0Nwk6+aDtYqc4OOaJK6saYeoqdWM5bI1IvM8lPOCiXaN4Q5Ge+PaqOsaPb61bRQzyTRGGVZo5IWAZHGcEZB9TQ1dWFTqOlUU49O5HpWgW+k3l1dRT3M010F85ppN24rnB6dea1aErKwVqzrT55K223krGfa6PBaaveakk07S3YUOjvlFx6DtWfe+E4L7UxqD6nqaTqWMflz4Ee7qF44FS4JqxvTxsoT5+VPS2q6Wt+W4uu6RPqes6HKgYQ2k7TSuHxjAGBjvkjH0zW/TS1bM6tRSpwiuif5szNX0S31n7MZpZ4ntpPMieF9pDYxnOKXSNFt9HSfypJppbiTzJpp23O7e5o5Ve4/rU/Y+xsrd+u9/zNKs7T9Hh02e+mimuHa8l81xI+Qp/2fQU2ru5lCo4xlFdf+HM7TvCFvpdwJbfUtTx5vmvGbj5ZG77hjnNTz6VeXPiy01N5IEtbSJ0RVyXcsBnPYAVPJZWR1yxqqTdScUnZrRd1bU26Ks4AooAKKACigAooAKKACigAooAKKACigAooAKKACigAooAKKACigAooAKKACigAooAKKAGSyCKF5GztRSxx7Vy2ieI7zV/EMayRfZrKSwM6RFlbJ8zaGzjI44xQAzS/Fcj6td6dOPOkS5nO4kII4kxgDj5j1460W/jgz2ktyNJmEUcYm3BzjZu2nnb1Gc4GeO9AE1x4x8q1W6SwLWz3EkKzGUhMLgBiQpxk5A+nWmS67fCG9vUkUQ2+ppaiPaDmP5Vbn1JbP4UAdZRQAUUAFFABRQAUUAcl4h8S3dtdz2VjCUa3eDzbgspwHI4Ckc8d60tb8Rx6JMizQF45IZHRw+Nzr/B06nNAFWXxaIdWt7B7QbpWSORllJMTsudp+XHH1/CqWm+Lpk0uJryPz5vsk100m4JnY5AXAHt1oAsr4zV9Uhs006Vwwh8x1YnZ5igjjHIGRk5FQy+Lbi5ikghtxZ3X2mKALI251DNgsVKgdB6kcigDZ0y+nm1bVrCdt5tZEaN8AfI65A+owa1qACigAooAKKACigBCARgjINZKeF9EjV1TToVDrtbGeRuDY/MCgCwNF04SrKLRBIszThsnIdup/Gs9NBtJNOvYtOSOwkuGeF3VN42hiCME4GRQBZHhvS206zsp7ZZorRdse/8ADJOPUjNMfw5avLKfNlWKW7S7aIY271HTp0JAJ+lAGzRQAUUAFFABRQAUUAZ91oemXt39qubKKSfAG9hzwcilbRdNaFYWtIzGk32hVOeJP71ADX0LS5L83z2URuiwfzMc7h0NU7bQtIv7CDz9OgKwtIiLzgDeQe/frQBcOg6WbqG5+xx+dCFWNxnIC9Prj3qvJ4W0s28sVvB9meR0k82P7wZTkEZz37UAXbLTo7Ke7nDtJNdS+ZI7YzwAAo9gBVygAooAKKACigAooAKKAEZlRSzEKoGSScACqOkTRzWspSRXxczA4OcfvGoAv0UAFFABRQAUUAFFABRQAUUAMllSGJ5ZDtRAWY46AVn+Hpo59CtZY23K6l8jp8xz/WgDTooAKKACigAooAKKAM+e6kGoRQq6ogchgRyRsJz9M/ypLa+aRLVd8eHTl2OdxBxge/U0AWLKZ5opPNZDIsrqQoxgBiBkZ9MH8arS380InzEW2H5c/wAQL4J9MKOv9OpAHrfTNJHGYBl4/M3Fvlxg55Ge+38GqKxdV+yQW8McNsRISIlCruBGAMEjByx/CgCxa+ZLbOfNYN9of5jzwJCMc+wxTRePLqElmvH7tiHxypG0dM/7We3TvQBbVghSFnzIVJ56tjAJ/UfnQyszIVcqFbLDH3hgjH54P4UAUba4nuTNAXClQCJFGSDubgjpnAH5/nYYn+0Am5trQkkbjjqPy60APtHaS1jZjkkfe/vDsfxHNTUAFIThScE4HQUAZsV+zW4mlljUNKgx0wCFyPwJP5dqle7kMNwyPGrRvjaVyVGcZPPcc0AWndvszSRBXbZlRnhjiqR1I77fCfLK2ACMEqTgEc/Q9O/agBn297ezZnPmMrzL83XKlto+pAFKb+VPPVYY0WHAG5gABnHTPpkjp0/GgCaG4eaV2LEDyFdFxjrnJ/QfT8aTzvJ+wqZgBIcMGOS3yk9T74oAtxyxy7vLYNsYq2OxHaq0Uvm31xEJy6KACnAKH2xzjHf1oAjgmlMemnJcyxjzc+mzO788D/gVaFABRQAUUAFFADXjSQAOoYD1FO6DAoATYu/ftG7GM45xQQDjIBwcjNACKiJu2Iq7juOBjJ9adQAm0bg2BuAwDS0AFMMUZZmKLuYbWOOSPSgB9FABRQAUUAM8qPzPM2Lv/vY5p9ABRQAmATkgZxikREjQIiqqjoFGAKAFVFQEKoUEknA7nrQyq6lWUMpGCCMg0AARVxtUDAwMDoPSloAKKACigAooAKKACigAooAKKACigAooAKKACigAooAKKACigAooAKKACigAooAKKACkJAGScAdTQBjv4t0COfyW1a1D5x9/j8+la6OkiK8bK6MMqynIIq5U5Q+JERqRn8LHUVBY1ZEckK6sR1APSnUAMSWOR3RJEZkOHUMCV+vpT6ACmCaJgxEiELySGHFACxyRzRrJE6vGwyrKcgj2NJJNFFs8yRE3ttXcwG5vQepp2ewrrcfRSGFFADI5Y5d3lyI+1irbWBwR2PvT6ACmebHv2eYm7ONu7nNAD6KACigAooAKKACigArhPGHjqDTbi50dLNp2aIpM/m7Nu4duDng1th6TqTsY16ns4XPLdT1BL50k2zCRVVMySK3yqMAYCivYPBmoeV4b0q2kjI3RcNn1JxTzbErDUoNq95JfmY5fT9pUlbsdbRWB2HnWleFdQkvNQ1Hzzp8izXIiZVKySFvulieNo6ioGm1vXfDR1KSS9KPeQARW3JCRjDsox3fJ/AV3c8JO76WRxck4qy63JktdattemvrM6gscuoWqsjx8SxFPnZ+O2AD2GTToJ/FPmXm86iZvs1yZlaP92sgJ8ryiBz26ZpP2b3sC9otrm34XGsRahdRahNdzQtbQSK1wvSQj5wDgdD2rldE0m+SWya20u7tbmBLo3k8kZVZVbOxRn7x6UoyinK2i0/L/ADKcZNRvq/8Ago1NM/tmO50eC8GqQWq2sW1LSIBfM3fMJOOBj6cVBYWmqxQ28ckeoSXCa2ry+fHlAmX+dTjoeMn6U24a2sJKel7kcFx4u+zXxY6iZxauZA8fyrN5nyiLA5G3+tWppPEVpaalb79Tucz24imx86hlJkIwvIB4wBxmhqleyt/VhJ1ba3/q4/SV8S3sukwX1zf2yeXN9pcIASVf5QSRwSO/cVd8M3Gq3WuXNtdXbyQaYrQOxbPnuzkqx+iY/E1E/Z2fKtv8y4e0ursztLi12z1u4XyLiOxlvLp49ikbpCBtMnH3PTHfrVWxm8VLpd/dXd5cxPbRCfbOrLl1bJUEgDBXIwCe1X+6fnsR+8X4k95c+IZNF0+/t5b95LqeWcwQKSRGxGxdwB24HPIxyfSiXP2e/ZwRf/8ACQx7M/e6rs/DZn9aEor4f61BuT+L+tD0SiuI7QooAKKACigAooAK8y8QeEL+58dLf/ZRPpssiSSMGGFAAyGHXt+ta0qvslKXkzGtTdRJeZuCwtHJ2WVmMesSL/StC0sLmS5ilZQIwQd24EYH0r4mk8Zjpx5pcyTvvt52Pa5aNCLsrfI6GivsTyyOeCK5geCeNZIpBtdGGQw9DRBBDbQpDBEkUSDCoigAD2Ap3drCsr3JKKQzlJPG8Mer3FgbQssazFJUlyGMaliDxxwPfFQL4/QWsss2lzRuII54E8xT5qu20c/w8mulYZ9zm+sLsW9H1zUZ9H1m8urYyT2d1KiW6kAhVAO3I6nk896j/wCE3geyubuC13wxNCkZaXb5ryLu2jg8gdqXsU27Mftmkroor45klmivY4WFn/Z0tw9u2N29JNv3sVduvHENrHeFrN2aA26qA/3zKpYduMYPrVPD62T/AKuJYjS7X9WGSeOVW0sZjpkqi6kaNzK+xIyCB94jvnIziobPUpbC0S5tIbeCzk1g2ogjiCgx5KbiRzu3DP6Uey5VZvcPa8z0Wx2tQXdnbX0HkXcEc8WQdkihhkdODXMm07o6Gk1ZkyqqKFUBVAwABwBUf2eAyeYYY/MyG3bRnIGM5+lF2FkS0UhhRQAUUAFFABRQAUjKHUqehGDSaTVmC0MwaMqSh0ncYORlQa0IYlghWJckKO9efgsujhZNqV/6/wCAb1q7qKzRJRXomAUUAFFAGQPC+ircPcCwQSuXLNub+MEN34yCac/hrR5IjE9jGyGBbfBJ/wBWpyB17Hv1rT20+5n7KHYs6fpdlpdu8FlbrDE7l2UEnLEAE8/QVV/4RnRhYCxFhGLYTeeEDMMP/eznOaXtJXvcfs42tYWPw1o0SbEsIwnlPDtycbGOWGM9zUcfhTQ4bWW2TToxDLtLrubkrnac5zkZPNP20+4vYw7DpPDGjyxwxyWYdIs7Q0jnqcnPPPPPOaiHhm3EgHny+QL77cIeMB8dP93POKarS6idKPQ3KKyNQooAKKACigAooAKKACigAooAKKACigAooAKKACigAooAKKACigAooAKKACigAooAKKAP/9kA/+Ex5Gh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8APD94cGFja2V0IGJlZ2luPSfvu78nIGlkPSdXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQnPz4NCjx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iPjxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+PHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9InV1aWQ6ZmFmNWJkZDUtYmEzZC0xMWRhLWFkMzEtZDMzZDc1MTgyZjFiIiB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iPjx4bXA6Q3JlYXRvclRvb2w+V2luZG93cyBQaG90byBFZGl0b3IgMTAuMC4xMDAxMS4xNjM4NDwveG1wOkNyZWF0b3JUb29sPjx4bXA6Q3JlYXRlRGF0ZT4yMDIxLTA4LTIzVDE5OjE2OjUyPC94bXA6Q3JlYXRlRGF0ZT48L3JkZjpEZXNjcmlwdGlvbj48L3JkZjpSREY+PC94OnhtcG1ldGE+DQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8P3hwYWNrZXQgZW5kPSd3Jz8+/9sAQwADAgIDAgIDAwMDBAMDBAUIBQUEBAUKBwcGCAwKDAwLCgsLDQ4SEA0OEQ4LCxAWEBETFBUVFQwPFxgWFBgSFBUU/9sAQwEDBAQFBAUJBQUJFA0LDRQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQU/8AAEQgBiAMgAwEiAAIRAQMRAf/EAB8AAAEFAQEBAQEBAAAAAAAAAAABAgMEBQYHCAkKC//EALUQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+v/EAB8BAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYHCAkKC//EALURAAIBAgQEAwQHBQQEAAECdwABAgMRBAUhMQYSQVEHYXETIjKBCBRCkaGxwQkjM1LwFWJy0QoWJDThJfEXGBkaJicoKSo1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoKDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uLj5OXm5+jp6vLz9PX29/j5+v/aAAwDAQACEQMRAD8A/VOiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAornfHfxC8P8Aw10J9X8R6lHptiG2KzAs0jnkKigEseDwB2z0ryfwf+2V4M8deONM8M6Tp2svcX83kx3U8MaRA4Jz/rC2OPSspVYRajJ6nrYbKcdjKMsRQouUI3u7aab6+R71RRRWp5IUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFfOlr+3T8Pv7Ym0/ULPWtMMMrRNcSWySRAgkE/I5bHH92s51IU7c7tc9PBZZjMxU3hKTny721tf/hj6LorO8PeItM8WaNa6to97DqOnXS74biBsqw6fgQcgg8ggg1o1pvqjzpRlTk4TVmugUUUUEhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRXzX+0J+2HbfCzWpfDnhywg1nXYAPtU1yx+z2zEZCEKQXbHUAgD1JyBlUqRpR5ps9XLcsxebV1h8HDmlv5Jd2+h774wleDwlrckbtHIljOyupwVIjbBB7GvhD9k34r+M9c+OPhvR9T8VaxqWl3AufNtby9kmRtttKy8MT0ZQfwra0v8Abq8SX2n3lp4r8O2Umm39vLbpdaYkkLoWUjdh3ZXAJ6Aj6151+xz/AMnGeE/pd/8ApJNXlVMRGrVp8j6/5H69lfD2IynKMyjj6avyNxej2jLZ9Gn6H6Y0UUV7R+GBRRRQAUVxvij4xeCfBerNpmu+JdP0u/VFc29xLtcKehx71k/8NHfDH/odtI/7/wBZupBaNo9GGW42pFThQm09mou35HpFFee2X7QXw41G8gtLbxlpU1zPIsUUaTZLsxwAPckivQqqMoy+F3Oetha+GaVem437pr8woooqjmCiiigD4h/4KG3Fz/wkfg6Bnb7GLSd0TPHmF1DH64C16r+yn8F/BVr8NfCni2PSI7nxDPG1w2ozszOkm5lIUZwoGMcD6157/wAFEo4CngV96i6U3g8vPJQ+Tzj0yP1Neu/sZ3Ulx+zz4dWQECGW6jUnuv2iQ/1I/CvKhFPFzur6f5H67jq9anwZhJUZON5uLs7XV5791oe3UUUV6p+RH5//AAZ+MXxB1z9oDRPD2o+K9Su7A6nJDNbSSZV0QOSp46fLX6AV8R/CL4JeLtB/auOuXvh68tvD8Op6jKl9ImImRknEbA+hLLj619uVwYNTUJc/c/QuNKmEni6H1NRt7NN8trXbe9uoUVzfxH8XyeAfAuteIo9Ok1Y6bbm5a0jkEZdVI3HcQcALljweAa+M9S/b68calcONG8M6PbRddsqTXLgfVXQf+O1tVxFOi7SPDynh3MM6hKphIrli7Ntpa/n+B94UV8SeB/8AgoHqi6nDD4v8PWclg7bXudJ3xyRD+9sdmD/TK19oaTqtprul2mo2E6XVjdxLPBPGflkRgCrD6g1VKtCt8DMc2yHH5LKKxkLKWzTun8/8y3XwB+0Z8ZPiD4V+OviPQtI8V6jY2Mc0Agt4pMKgeGN8AY9Wr7/r4j/aD+CXi7xV+0mNZ0zw9eXujXE1i0l5EmYwFWNHyc9gtc+MU3Bcm9z6LgmphKePq/XVHl9m7c1rXvHv1tc+21G1QM5wMZNLRRXefnoUVwvxm+LWnfBfwPP4h1CB7s+YtvbWkbBWnmYEhdx6DCsSecBTwTxXkvwG/bGt/ix4yj8M6toa6LfXSu1lNDOZY5GVSxRgVBU7QSD0OMccZxlWpxmoN6s93D5JmGLwc8fRpXpQvd6dN9L3dutj6UpskiQxvJIyxxoCzMxwAB1JNOr5/wD2vPhp42+IvhfSoPCN5dTRrceTe6PFKsUdwrkbZGJIyFI5BOMHOBiqqScIuSVzky3C08bi4YetVVOMnrJ7L+vl6mV8Vv24fC/gnUDp3hq0/wCEtu422zTxT+Vap7LJtbef90bfc9K7f9nP48S/HfRdXv5dGTRjYXCQCNLkzb9y7s5Krivkv4xfstJ8Ffg9a69qup/b/EdxqMNs0VtxbQI0cjFQSMu2VHzHA9u9ev8A/BPX/kTfFv8A1/xf+i686nWrOuoVNL9D9OzTJsjp8P1MZlyc5Rko87b1d0npora9v8z6zooor1T8fCiiigArwT9s7xf4g8D/AAs0/U/Duq3GkXn9rRRSTWzbWaNopsqfbcFP4V73Xi37XXgvVvHfwcudO0TT5tT1FL2CaO3gGXIBIJA9gxrCvf2UuXc+g4flSjmuHde3JzK97Ws+99DD/Yq8aeIvHnw71rUvEWr3Or3Caq1vFJctuKKsMbYH4vX0LXhf7HPgfWfAPwlnsNd02bS7+bU5rg29wuH2lI1B/HZXulLD39lHm3L4ilRlm2IeHtyc2lrW+VtD4G/bA+KnjLw98ZtU0jSvFGraXpsdvbsttZXkkKAtEpP3SOpNfanwzuJbz4ceFJ55Xnnl0m0eSSRizOxhQkknqSe9fAP7a/8AycBrH/Xta/8Aola9C1L9ty/8N+F9C0PwXolvejTNMtoLvUNRSRk3rEquFRSpABBG5jzjpjk+dTrxp1qjmz9MzLIa+aZNltPAUlzcqcnovsrVv1+Z9w0V8m/A39t1/Gfiez8P+MtNs9NnvpBDbahYFlh8wnCpIjsxG48bg3UjIxyPrKvUp1YVlzQZ+U5plGMyat7DGQs3quqa8mcH8dtU1HRPg/4s1DSbuSx1G1sXnhuITh0K4JI/AGvnf9if4neMfiB441+LxD4hvtXs7bTgyQ3L7lWRpVAb64DD8a+mvito8/iL4X+LtMtYWuLu80m6ggiQZLyNCwQD3LYr52/Yg+FfifwBq3i268SaJd6P58FvFB9qTb5nzSFsfT5fzFctRT+sQtsfU5XUwkeHMcqqj7W65b25teVadfuPrOiiiu8/PQor5r+PH7Y9v8J/GUnhnSdDXWr21CG9mmnMUcbMoYIuFJY7SCT0Gcc849a+DPxZ074z+B4PEWnwSWZ8xre5tJGDGCZQCy7h94YZSDxww4B4rGNanKbgnqj3cRkmYYTBwx9alalO1np1203V+lzuJJFijZ3YIijLMxwAB3NfKXxU/bx0vw7qk+m+DdKTX2hYo+pXUhS3LDr5aj5nH+1lR6ZHNfVN3aQahazWtzDHcW0yNHLDKoZHUjBVgeCCDjFeU+Cf2Wfh/wCBfFeoa9ZaSt1NcMGt7e+xNFZevlBhxk9zkjoCBmprKrKypux05LWyjDupVzSnKo0vditE35vf9N99EfOGj/8ABQjxRDeIdV8MaRdWmfmSzeWCTHszM4/Svrj4U/FjQfjF4XTWtClfYreXcWswAlt5MZ2sAfQ5BHBFeZftleB/D9/8E9Y1i4sLWHVNNML2l2karIpaZEKZHJUhj8vTOD2rxX/gnveXi+O/FNqhb7BJpqSSjt5iyqE/HDSVxxqVaVZUpu6Z9pi8vyrOMiq5tgaHsJ0nZq909v0emid9D7qr44/bT+C/gvwf4BtvEmjaRHpOry6mkDvbswSYOkjMGUnGcpnIAPWvsevlX/goRdSL8PfDNuAfKk1QyMe25YXA/RmrpxSXsZNo+Y4Qq1oZzh6dKbipPWzsmkm7PuWv+Cf1xdS/CvXY5HZrWLV2EIY5CkwxlgPbkH8T619QV85fsHJbx/BKfyZFaV9WneZQeVbZGAD/AMBCn8a+jarDfwYnNxVJSzvFNK3vMKKKK6T5UKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAo67qi6Hoeo6i67ks7eS4K+oRS2P0r8vPg3oQ+K/xz0Gz1pjeLqmotdXu8/64DdNID/vbSD9a/T/AMTaW2t+G9V05Thry0ltwT6uhX+tfmL+zxr0Pgf47eFb3U2+yRQXxtp2l+UReYrREt6AF+fTFeTjP4lNPa/+R+xcD3jl2ZTofxVHTv8ADK1vmfo/8R/DOk6x8N9b0u9062uNOSwl2WzRjYm2MlCo/hK4GCMYxxX59/sc/wDJxnhP6Xf/AKSTV+hHxQ16w8N/DvxFf6ndR2dpHYzKZJDgbmQhVHqSSAAOSTX57/sc/wDJxnhP6Xf/AKSTU8Vb29L1/UXCbqPIM0cr8vJK3a/JK/z2v8j9MaKKK9U/HgooooA+efjV+yHa/GTx1N4kl8TzaU8kEcH2dLISgbBjO7eOv0rg/wDh3dY/9Dzcf+Cxf/jtXP2kf2f/AIk/ET4nXGseGJ0j0p7aGNVbUDD8yjDfLXl3/DIvxq/5+o//AAbn/GvHqRjzu9Fvz1P2vK8ViY4GjGOcwprlXuuMG46ba66Hq3h39gWy8P8AiDS9UXxpPO1jdRXIiOnKofY4bbnzOM4r6xr4P8Ifsq/GHSfFmi317cxmztr6CaYf2qW+RZFLcZ54B4r7wrrwqSTtDlPjuKqtWrUpOpjo4nR6xSXLtpp3Ciiiu0+FCvKP2mrzxfY/C2eXwOuotrv2qEKNLhMs3l5O7CgE46dq9XoqJx5ouN7HZg8QsJiKddwUuVp2ezt0Z+U32sax48Vvi1f+J0Zdqzlot94q54H75hsUZ7A9TgV+mXwzh8N2/gHQ4/CBibw2LZfsTQkkFDySc87s53Z53Zzzmvln/gojHaL/AMINIIk+3P8AbFMoHzGNfJwpPpljj6n1NevfsY28sH7PPh1pCSsst06A9l+0SD+YJ/GvMw0fZV5Ut/PqfqvFFZZtkGFzRXgnLl5E/d+0rrRa+7p5Ox7fRRRXrH48FFFFAFXVDZjTbr+0TANP8phcfatvleXg7t+7jbjOc8YrxHUP2tPhB4Gzp2nX6zxwnb5Wi2J8lcf3ThUI91JFcN/wUE8WajpfhXwvoVrK8Njqs88t3sOPM8kR7EPqMyFseqj0rnv2Lfgh4L8beDdR8R6/p8Guail81oltdHdFAiojAlM4JYseTngDHfPn1K03W9lTSv3Z+kZfkeBo5L/bGZzm4SdlGFu7V3fzT7ad72PIv2pPiV4L+KnizTtb8JWc9rObdo9Qee3WEyuGyjEAnccEgk88D0r7P/ZFupLz9nfwfJKxdhHcRgn+6tzKqj8AAPwr5c/bg8P+E/Cvizw7pnhrTdL0qeO0kkvbfTYEiI3Mvllwo64DYzzj619OfsdsG/Zz8JAHOPtYPt/pc1c+HusVNS3t/kfQ8Syo1OFMHPDxkoc6tzO8rWnu/wAvKx7PRRRXsH4sFFFFAHnnx1+ENr8bPAU3h+e6NhcRzLdWl1t3COZQwBZe4KswP1z2rxz9nz9je9+F/jmDxP4i1izvrixD/Y7XTw5Tcyld7swHRWOFA6kHPGD758TPiTo3wn8I3XiHXZJFtISESKFQ0k0jfdRASMk4PUgAAk8CvN/gz+1r4Y+MPiQ6BFY3mjaq6s9tHdFWW4CglgrKeGABOCOgPNcdSNB1U5/EfbZfic+hlFeng0/q2vM7LS696z3tbe23ke5UUUV2HxJ83ft7f8kVsf8AsNQf+ipq53/gnr/yJvi3/r/i/wDRddF+3t/yRWx/7DUH/oqaud/4J6/8ib4t/wCv+L/0XXlv/fF6H61R/wCSIqf9fP8A26J9Z0UVneItesvC2g6hrGoy+TYWED3M8mMkIiljgdzgdK9TbU/J4xlOSjFXbNGivkjQf+Cgmlah4sitNQ8LzadoU0ojF/8AaxJLEpOA7x7AMdyAxxzjdX1sCGAIOQaxp1oVb8jvY9fMsnx2UShHG0+Tm1Wqd++ze3VC0UUVseMFFFFAH5uftrf8nAax/wBe1r/6JWvuD4DeDdH8I/CTw3baXYxW6XmnQXVy20Fp5ZI1Z2c/xEknr0GAOBXw/wDtr/8AJwGsf9e1r/6JWvvL4O6hban8J/B89pPHcw/2Tap5kbBhuWJVYfUEEEdiDXk4a31ip/XU/YeKJ1I8OZbGLfK4q/b4Va/42Pzo/aU8J2vgH45eJtO0uMWlmk8d1BHD8oj8yNJcLjoAzEDHQAV+lfgTWpPEngfw9q8vMuoadb3TfV4lY/zr82f2m/Elt44+PXie80txd2xnjtIWh+YSGONIjtx1BZWxjrkV+k/gXRH8M+CfD2kS/wCs0/Tre0bHrHEqn+VGD/i1OXYfGjk8oy32/wDF5db7/DG9/na5uUUUV6x+OhRRRQB8s/tBfsb3nxP8cz+J/DusWdhcXwT7Za34cJvVQu9GUHqFGVI6gnPOB7J8C/hDbfBTwDD4fgujfXDzNdXd1t2iSZgoJVc8AKqgfTPeuP8AjN+1t4Y+D/iQaBLY3ms6rGqvcx2pVUtwwyoZmPLEEHAHQjmvSPhn8SNG+K/hG18Q6HJI1pMSjxzLtkhkX7yOATgjI6Egggjg1x040FVbh8R9tmGJz6eUUKeMT+racrstbL3bve1tr7+Z1VFFfGf7VP7VLXr3PgXwLctK0hNvqGqWpyXJ4MEJHXPQsOvQdzW1atGjHmkeLk+T4nOsSsPh16vpFd3+i6nKftkfH2L4haxF4J8OTfatHsJ91zcQ/MLu5GVCrjqq5P1Y+wJ+hf2S/gnN8I/AL3OqxeV4i1krPdxnrBGAfLiPuAxJ92I7Vwv7LH7K8Pgz7L4v8YxRvr2BJZabIQRZejuO8voP4f8Ae+79UrKjHCupPsa5MPSlKft6u728j67iHNsLh8HHIcqd6UPjl/PL/K+t/S2i1fXl37SNl4HvfhbfDx9NJb6QkitDNb/8fC3GCE8kYOXwWGCMYznjJr1GvlP/AIKEW8reAPC84YiBNTZGXsWaJip/JW/OunES5aUna58xw5h/rebYejzuF5brdW10+6x8qeEdU8T6T4ovI/hVeeJ5o3wdlpAwndcnHmxxM6nHqa/Sr4Szazc/DTw1L4hFwNcexiN4LtCkvm4+beuBg59q8e/YNjtB8FbiSCFEuW1WZbiQD5nYJGVyfZSK+jq58HS5Yqd9+h9Pxpm8cZi5YFUUnSlbn+1KytrotAooor0D81CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACvj/8AaE/Yv1HxV4qvfEvgia1DX7ma70u5fysSnlnjbGMMeSpxgk4POB9gUVjVowrR5Znt5TnGLyWv9YwkrNqzT1TXmv6Z8Q+Av2OPH3ii+sIfiJrk1v4bsWBXTxqDXMjAfwRjJSMY43ZyOw9Oh+A37H/jD4WfFrRfE+p6nodzp1j9o3x2k8zTNvgkjXAaJR1cZ56Zr69orCOEpRafVHvYjjLNcRTq0ZOKhUi4uKjZJO97ebvq/QKKKK7T4YKKKKACiiigAooooAKKKKACiiigD4g/4KGrcf8ACS+DWZW+y/ZLgI3bfvXcPy2fnXsX7KPxR8HXXwo8K+G4NesYdcgiaB9NuJljnaXezHYrYL5zkbc8H616j8SPhf4c+LGgf2R4jsftdureZFIjFJYXxjcjDof0PcGvIPA/7Ffh74fePtJ8TaZ4g1KX+z5/OS1ukjfdwRgsoX19K8/2VSFd1IK6Z+lRzbK8dkFPLMXKVOpSu42V1J+9b87Pbvc+i6KKK9A/NQooooA80+PnwTsvjh4MGlTXH2DUbWT7RY3m3cI5MYKsO6sODj0B7Yr5I0b9kv42+DtUni0HUV0xJfkkvdN1hrdJF7ZxtcjnutfoFRXLUw1OrLme59dlfFGYZTh3hKXLKm9bSV0vTb/I+Nv+GBru+8G3s2o+KFufG88izJO29rUYzuRmI3tuznfjIwPl659f/ZV+EevfB/wLqGmeIbhZLye/aaOCGcyQxx7VAK+hY7ieB2z0r2qinDD06clKK1Ix3E+Z5jhp4TFTUoSaey0t0Vtl/XcKKKK6T5QKKKKAPLP2kPg/P8avhu+iWV1HaalbXKX1o0xIjaRVddrEAkAq7c44OK8L/Zq/ZI8VeB/iRZ+KPFRtbGHTPMa3tYJxK88jIyAkrwFAYnrnIAx1r7Hormlh4TqKo90fT4PiPH4HL6mW0WvZzv01V9HZ+f8AwwV5H+038I9Z+NHw+tNC0O5sbS8i1GO7aS/kdI9ixyKQCiMc5cdvWvXKK2nFTi4vZni4LF1cBiIYqj8UHdXPgE/sA/EQ9da8Mn/t6uP/AIxSD9gD4iL01rwyP+3q4/8AjFff9FcX1Gifdf6/53/NH/wE4H4E+AdR+GHwp0Lwzqs1tcX9iJhLJZuzRHfPJINpZVPRx1A5zXS+MvDNr408J6xoN6zR2mpWslrJIn3kDKRuHuM5/CtmuY+J0mqR/DvxINDtZLzWHsJo7SGHG4yshVSM+hIP4V2cqjDl6JHxPt62Lx3t3K05zvfZJt3v5WZ+XngDwDJ4/wDiZpnhbTpjcx3d75P2lVx+4UkvLjJxhFZsZ7V+tEcawxqiDaigKB6AV8o/sYfADWvAOqa14l8VaVJpuo7BZWME5UsEOGkk4J64RQfZvWvrCuLBUnTg5Nas+647zeGY46GHoSUoUlutU27Nu607L1TCiiivRPzQKKKKAPkn9ob9knxf8Wvihf8AiTSNS0S2sbiGGNY76eZZQUjCnIWJh1HrXIeLf2PPiZ4Smu7HwN4imvvDt2SWtF1FrV+RysiZCP6Z746CvuWiuKWEpybl1Z9zhuMs0wtKlQjyuFNWScbrS1r9bq2mp8ifs+fsW3nhPxNZ+JfG89rNNYuJrTS7VjIolHKvK2APlPIVc8gEnjB+u6KK3pUoUY8sDwM2zjF51X+sYuV2tElokvJf0wooorY8UKKKKAPjf9pT9kfxT43+I954o8Km2voNT2NcWs84ieCRUCEgtwVIUHrkEkY6V7t+zf8ACCf4K/DdNEvbqO61K4uXvrtoSTGsjKq7VJAJAVF5wMnNepUVzRw8IVHUW7Pp8ZxHj8dl9PLazXs4W6au2iu/L/hynrNnJqGj31rEVWWeCSJWYkAFlIGfzr4M/wCHf/xD/wCgz4Z/8Crj/wCMV9/0U6tCFa3P0JyfiHHZGpxwbS57Xur7X/zPgD/h3/8AEP8A6DPhn/wKuP8A4xXq37NX7J/iX4QfEZ/EOv3+j3dsllLBCmnzSvIJWZOSHiUY2h++eRxX1TRWUMHShJSXQ9bGcaZvjsPPDVpR5ZqztHoFfIn7b3xS8HeJPhzZ6DpevWOr6wmqRz+TYzLMIgiSKxdlyF+/jGc89ODX13XzBD+wR4TuNauL7VPEGrXiTTNMbeARwjlicE4Y457YqsRGpOHJTW5ycM18tweLWMzCpKLp2cVFX5nrv+HYb/wT9W4X4W6+XQi2bWGMbHoW8mINj8lr6hrH8JeEdI8C+H7TRNCsY9P0y1XbHDHk9eSSTyxJ5JJya2K1owdOmoPoeTnWPjmeYVsZCNlN3S8v8wooorY8UKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiivH/ANpD46N8F/Dtn9gt4rvXdSdltknyY41UDfIwBBONygDIyT7EUAdp8VPHi/DHwFqviZrI6itiIybYS+WX3yIn3sHGN+enauN+Av7QUfxwm1qNNDbRv7NWFiWuhN5nmF/9hcY2e/WvlrxF+0Z468b/AA31zTfEmmre6HqQWGPU4LQxLDMkiSBd4+Vh8uCOvOc8YPoP7An/AB++Nv8ArnZ/zmoA+wq+dtd/a+h0T4oT+Dj4WeZotSXTvtn28AHLhN+zy/fOM/jX0TX5zeO1LftSXwHU+JkH/kdaAP0Zor5c/aA/au1Dwj4uTw14JW1u7u1by724liMwMp4EKAHkjv7nHY16to/jTXfAfwjuPFXxHlgF/FF9oktLOEJ5W7Ajh6nLkkAnOAWx0GSAem0V8U2f7TXxg+JWpX8ng7RIvsloPMe3s7P7QY0Odod26scHoBnBwK9N/Z1/aau/ipqlx4Z8QWsFhrwhaS2ubZSI5tv3lKMThwOeuCAemOQD6Jor5C8H/tPeOLP40WfhHxb/AGetoNSbTbnyLYxtvJKIwbd03lTn0rtv2pf2gNZ+Emo6Fpnh02v266ikubn7VF5m2PIWPAyOpEn/AHzQB9D0V86+JP2hPEXw7+BfhvxHrNpa3vinXiXt4fLMcEUZBZWYA5PybDjI5frxXmej/H3476ro6+JbHRo9U0QswBg03zI/lOGGEO/AI65/GgD7N1LUrbR9Pur+9mW2s7WJppppDhURRlmPsAK8y+Fv7RWifF7WL/T9B0fWD9ihM0tzcxRJF1wq58wnc3OAR2OcYrz39prx7rMf7OOjHUrePTdY8QvAl3bQFgIk2mVl55H3UUj3Irc/Yt8KxaH8H01XZ/pOs3Us7P32RsYlX6Aq5/4EaAOh+Hv7S3hj4h+MpvC0Nnqmj6xH5gEOqRRpvdD88Y2u3zAAnBx90163Xwb+01ayfC39o238Q6aPKkn+z6wirwN4Yq4/4EYyT/vmvu21uo721huIjuimRZEb1UjIoAlooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoorwb9pv9oe5+D8dhpOiQwT69fRmcyXALJbw5KhtuRlmIbHYbTnNAHe/Gj4qL8H/Bv9vvpraqPtMdv9nWfyvvBjndtbpt9KzvgT8ak+NmialqKaQ2jizuBb+W1x52/Khs52rjrXx94/8Aj14z+IPw1fTPFWmeZZXVzHPY6rHatCrOhIZM/dcYJ6cgjv29v/YN/wCRH8S/9hFf/RQoA+n6KzfEi6k3h/Uv7HeOPVvs8htGmXcnm7Ts3D0zjNfMv7Pf7Tnijx58TovDfigWaRXMEywrDbmJ1nQbsHJP8KuMeuKAPqyivlf9o39pzxJ8O/iN/wAI74Z+xslvbRm5+0QGRvOfLBRyONhT869P+JHjbx14B+Dun61aaZa6x4mAt1v4jE5SNpBhikaHLYcquM980Aes1n+INWGg6DqWpmLzhZ20lz5e7bv2IWxntnFfGOv/ALQ/xz8H29tq2uaSNM0+aTYi3uleXGzYJCnOGBwDwSDwa968F/FqP4yfAfxFrJtlsr6Gyu7W7t0JKrIsJOVJ52kMp56ZI5xmgDK+C37U8Xxi8ZHQE8NvpRFtJc/aGvRL90qMbfLX+969q95r4H/Ym/5LQ3/YMn/9Cjru/Ef7UHjXS/jhceFYG0/+yo9bWwG62zJ5RlC/e3dcHrQB9e0V4R+1R8ZPEPwhsfDsvh82oe+knWb7VD5nCBCMcjH3jW78Jfi/NrXwMXxz4qlijMK3Etw1vHtG2ORlAVc9TgADPJNAHrVFfFiftSfFb4ma/dQeBtDijt4VMgt7e1+0SLHngyO3GT7Ae1d9+z7+1HqXjrxX/wAIj4usYbPWH3rb3ECNFukQEtHIhJ2tgNyMdMYzQB9K0V8q/Hr9qnxB4V8e3HhHwjZ2yz2rpDLeXMfmPJKwB2opIAA3AZOcn073Phr8Uvja3xC0fQPFXhtPsN9JiW7uLJohHGqlmZZEOzIAPBzk4HGaAPZfix8YNB+Dmi22o639omNzL5MFrZqrTSEDLEBmAwBjJz3HrWNd/tAaZZfCy38fSeH9cGizShBGIYvOVCSqysvmYCFuAc55HGDmvmT9q/U7nx5+0BZeGIpD5doLXToV6gSTbXZvr+8Uf8BFfZmreCdO1PwHc+ExEI9MksDp6J/zzTZsXHuOCPpQBQ+F3xS0T4ueGv7Z0RpkiWVoZbe5ULNC45wwBI5BBBBPB9ciuwr4d/Yl8RXGg/FDV/DkzFYr+0fdFn/ltC2Qf++TJX3FQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV8W/t6W86+LfC07A/ZnsZUT03LJlv0Za+0q4D4zfBzS/jN4ZTTL+ZrK7t3820vo1DNC5GDlcjcpHUZHQc8UAeHjxj4W/4Yq+wC/shcfYfs32LzF837T52fudc7vn6dOenNZn7An/H742/652f85q2/C/7Cel2UeoHXfEMmpSywPFa/ZrcwrBIRhZW+clyOu3geua9B+Bv7OafBqPxDHJr7a0msRRxNttPsxiC78kHzHznf7YxQB6DoPxK8K+KdXuNL0jxBp+o6hbgmS3t51dgAcEjHUA9SM1+fHxkuLy1+P3iWfTvM/tCPWme28pdz+aJAU2juc44r6l+Dv7JS/Cv4iR+JZPETajFarKtrbrbeWx3qUzIdxzhWPAHJweMYqHXv2QP7c+KVx4x/4S3yfN1NdR+xf2buxhw+zf5o9MZ2/hQB8ueEbu/+B/xh0u88V6MzXNhOk1za3QDuFdc+YpzguA24HP3h619a/tdXI8Qfs/vqOlzC60+S4tbkzRHKvCx+Vvplkrb+PH7Oen/GyXTbwal/YeqWYMRu1tvP82I8hGXevRuQc8ZbjnjU+GHwbk8E/D288G67rKeK9Gm3pHHNZmDy4n+9H/rGyMkkdCCT7YAPjj4AeDfG3jRdUtfBnjWDw1PGyPNZvfzW8k4wcOFjU7gORntn3r1r4Mfs4+IPAnxq0vV9T8T+H7+7tRcXNzZ2t5I926vG0ZfY0Y43Srkk96n8SfsGWtxqEkuheKpLO0ZsrbXtr5rRj03qwz/3z+Jr0P4C/sywfBXXLvWZNek1e+uLRrTYtsIYkQujk/eYk5Qc5HU8UAeJftseB5PDfj7S/F9iDFHqiBZZE/guYsYbPYlNmP8AcNcVq+pXH7S3x+0pArLBfm2gZF/5YwpGGmx9MSt+Ne9ftdfEnwTq3w31Hw8NTg1DxDDeoILW3bc9tNG+2Qv/AHcLvXnkluPUcn+wr4AaS+1vxjcw4jiX+z7NmHBY4aVh9AEGf9phQB7V8fvhz4Y+IHhPTvD+qazaeG7tZd2lTTOqrvVdpjCkjcNpHAOeAe1fH3iHw98Qv2YdctZrbWRaRXZZoLjTboSW9ztxnfGeuMjh178Zr7I+PXwNj+N2j6baHV20eawleWOQQCZW3AAgjcvp614ppf7A7C9Q6j4wDWgPzJa2OJGHoCzkKffB+lAGL+0j40uviV8Bvhx4nuIFgluridZ0jzs81dyEj0BMbED0NfQn7L0yTfAfwk0ZyohlU49RPID+oNYHx++Dttefs/nQPD9o3/FPrHd2cA+Z3EYYPz3Yo8h92+tcv+w547i1TwXqXhWaRReaXObmGMnloJDk4Hs+7P8AvrQB53+3fMjfEbQIx/rV0oM30M0mP5GvsTwVE8Hg3QY5BiRLC3Vs+ojXNfEXj3f+0R+1B/Z2nH7TpaXCWXnR8qtrD/rZM+hPmEHvuUd6+9lUIoVQFUDAA6CgBaKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK+Cv23LeaL4yQSSA+XLpcDRE9NoeQHH4g19615b8dPgLpnxs0u0Wa7bS9Wsi32a+SPzBtbG5HXI3KcA9QQfqQQDyL4zeMPC2ofsl6FZWWoWUtzJb2EdtaxyqZY5EC+YCo5BUBwT6n3q9+wnNHb+AvFEsrrFFHfqzu5wqgRAkk9hUWh/sJ6Vb6HqcOqeIpbvVbiMLa3UNvsjtGDA7tm/94SBjkgYJ74I9C+GP7OcXw9+Hvinwpca8+qQa8siPcx2vkNErxeWcDe2TzmgD0Lwv8RPDHjaa5h0HXbHVpbbmWO1mDsozjOPT36V8VfG/SJPgp+0pba/aoY7Ge8i1mIL0IZ/3yfiwk49GFe//AT9mE/BnxRf63ca9/a001s1pFHFbmFVRnVizZY5PyDjoOevbo/j18BbX44afpUTan/Y17p8rsl19m8/dG4AZCu9e6qc54weOaAPlj4R6W/xy/aan1i5Qy2Ed7Lq8wbkCJH/AHKH1GfKXHpmvWf2uvjx4j8Aa1p3hnw5c/2Y89mLy5vUQGQhndFRCR8v3CSRzyMEYOfSfgJ+z/a/A+31YjVf7avdQZN1ybXyNkaA4QDe3diSc88ccVB8e/2c7D42NY3q6i2j6zZxmFLjyvNSSPOdjLkHgkkEHjceD2APlf4meFPF8Pwh0PxV4m+IFxrEGsPFLbaLNeSzcMrMHwzbQVHBwvBbGa9O/ZR/5IF8R/8At5/9JRWv4d/YV0iz0rUo9Y8QTX+oTwGO0mht/LjtX6iQrvJkII6EgYJ74I9H+E/wB/4Vh4B8SeGf7e/tP+2PM/0r7H5Xk74vL+75jbsdeooA+ZP2Jv8AktDf9gyf/wBCjrmPiNeRaT+0xqt5dN5UFv4jE8jN2QTBifyr6j+Cf7K//CnfGh1//hJ/7XzayW32f+z/ACPvFTu3ea3Tb0x3qL41/sk6f8UvE0viHTdYOialcBRdRvB5sUxAChxhgVbAGeoOOgOSQDzb9ubxhpGuN4R0/TdRttQmhFxcTfZZVkCK/lhMkE9drflU+mW1zdfsGXi2wZmWVpHVeuxb4FvwABJ9ga3oP2EdIXwtNaSeJJm12SZHXUvsuYokAOYxF5gzuzyxb+EYA5z7V8LfhXb/AA7+GsPg+7uk121UTLLJJb+WsqSsxZSm5uMMR15oA+GvgF4V8XeL9T1Sx8H+MIPC99sjeSGS+ltnulBbG3y1O7bnnPTePevXPh9+zT4n8LfGTRNZ1nxZ4fvdSjvDfXFut7K95OOTIwVowWJyck+vWtnxZ+whp99qUtx4e8SSaZaOxYWd5bef5eeyuGBwO2QT7muv+B/7KsPwh8Uf8JBceIX1W9WF4UhjthDGobGSSWYnp7UAch8ev2eNP+KXjLU9Y8JeI9MXxGNqaho9xOoJkVQARjJRioXgjB65FeZfBf4weNvhb8TNO8H6veT3enNfx6bc6bcyicQFnCZibJxtJzhTtP6j2H4rfscH4heNdT8R2nigWMl/IJHtZrLeFO0Dhg4449Kt/CX9jfS/AHiaz17V9abXLuykE1tbx2/kxJIPus2WYsQeR05A60AeKfED/Q/2z4WuOFXxDp7nPZSYSD+RFfe9fE/7ang288N/EPSfGlkrLBfJGjTKPuXMP3c/VAuP9xvSvojXvjTp9v8AAiTx7bzRr5+n77ePd0umG0RfVZMg/wC6T2oA+V/2cf8AS/2p1mg5h+0ahJx02lJQP1Ir74r43/YX8B3E2sa14xuY2FtFF9gtmYffkYq0jD/dCqP+Bn0r7IoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAPNf+E51SH9pAeDWmR9FuPCZ1eOHygGiuI7wRO2/qQyyoNp4Hl5HU16VXiV1IB+2tpiZXLfD66IGeeNSt+34/qK9toA+evEH7GHhvxP401TXr/XNTKaheS3ktrCI0wzuXKhiDxk+ma9x8M+GdM8HaFZ6Po9ollp1omyKFM8DqSSeSSSSSeSSTWpRQAUUUUAFYGm/D/wvot5Jeaf4b0ixu5FZHuLawijkZW+8CyqCQe471v0UAYmg+B/Dnhe4kn0Xw/pekTyLseWwso4GZc5wSqgkZA4rboooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDxv8AZ5vJpfEnxss3dmt7Hx5PFbozE7Fk03T52AyeAZJpGwP71eyV4r+zr/yOnx7/AOygN/6ZtKr2qgAooooAKKKKACiiigCjrOhab4isWstW0+11SzZgxt7yBZoyR0O1gRkVmN8O/CkmkJpTeGdHbS0l89LE2ERgWQjG8Jt2hscZxmuhooAqaVpFhoNhFY6bZW+nWUWfLtrWJYo0ycnCqABySfxq3RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAeFzXyyftyWtmFYPD8OZpi3Yh9TjAH/AJDP5ivdK8MsInuf24Ndl8qLy7P4daevmEfvMzanenA9B/o/Pqcele50AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAeDfss280evfHmWXdib4kXrxliDlRYWCevqhHPpXvNeGfso+TJY/Fa4idpDN8Rdd8x2JOWScRYGewEYXj+7XudABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFQW99bXctxFBcRTS27+XMkbhjE2AdrAdDgg4PYiq99r2m6XqFhY3d/b217fsyWlvLKFecqMsEB5bAxnHqKAL9FFFABRRRQAUUUUAFFQQ31tcXU9tFcRSXNuFM0KOC8e4EruHUZAOM9cVPQAUUUUAFYXizx14f8Cx6ZJ4h1iz0WLUr2PTrSW9lEaS3LqzJEGPAZgjYz1IwOSBW7WP4w8H6L4/8Mal4d8Rabb6xoepQtb3djdJujlQ9j6HoQRyCAQQQDQB4doevabpP7XPxi8Ra5qNvpOlaH4T8Pae99qLpDDGJJtQmIErEADLLkHuw9s/QGm6jBq+n297al2t7hBJG0kbRsVIyCVYAj8RXzv8AAn9ju0+GPjjV/E/irW7jx5qlvcxw+G7nVHMjafZRQLFCWUja10qZiM3JKICCpllB+j5JEhjeSRljjQFmZjgADqSaAHUVkeF/FFp4u01tQ09JjYtIyQ3E0exbhRj95HnkoTnDEDOMjggnM8Z/ETT/AAReaZaXNlqeoXeoiU29vpdm1zIRGFLkqvIA3igDqqKoaHqy65pVvfJa3dkswLCC+gaGZOSMMh5B4qa41Kzs7q2tp7qCC4uSRBDJIFeUgZIUE5bA9KALNFFFABRRVax1Kz1ITGzuoLoQStDL5Egfy5B1RsHhhkZB55oAs0UUUAFFFFABRVabUrO2vLazmuoIru53eRA8gEku0ZbapOWwOTjpUl1dwWNrLc3M0dvbwqXkmlYKiKBksSeAAO5oAlopscizRq6MrowDKynIIPQg06gAoqtY6lZ6kJjZ3UF0IJWhl8iQP5cg6o2DwwyMg881Q8UeJE8K6at5Jp+pakrSCPydLtGuZRkE5Krzt46+4oA2KK57wV42sPHenXV3YQ3lsLW5ezmhvrcwSxyqFLKUPI+8Kn17xZY+GbzTYdR82CC/l8hLwp+4jlONiSNn5S5OFJ4JGMgkAgG1RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRUFvfW13LcRQXEU0tu/lzJG4YxNgHawHQ4IOD2IoAnoqhea9pun6pY6bc39vb6hfb/strJKFkn2DL7FPLYHJxV+gAooooAKKKKACiiigAooooAKKrahqVppFo91fXUNlapjdNcSCNFycDLE4HJAqLSdc03XoXl0zULXUYkba0lpMsqq2M4JUnBoAvV5x8S/jZp/wk8TeHbXxLpl5aeGtalWyXxQm17OzvHcJFDc87olkJAWUgpnhivBPo9ZPizwnpHjrwzqnh3X7CLVNF1S3e0vLOcHZLE4wynHI4PUEEHkEGgD5m/ZD+I0Vz4b17SfDWm3HifWr/xfrmrazeKGtrDTvP1O4dBLM4OZWhEbiGJGYb0LhFYOfq+uc+Hfw/0T4V+CtJ8K+HbX7HpGmw+VEpOXcklnkdv4pHYs7MeWZmJ5NdHQAUUUUAFFYviTxZY+F/sUdz5s95fTCC0srZN80799q56KPmZiQFAyTW1QAUVw+jfFrTdf119MsdI16YR3ctk18NNk+yLJG7I+Zfu4DKRmu4oAKKKKACiiigAooooAKKK4fR/i3pureJLLQ30jXtLvL3zBbtqemyW8cnlqWbDN14FAHcUVBfXRsbG4uFglumhjaQQQAGSTAztUEgEnoMkc1T8O+ItP8VaTDqWmT+fay5HKlWRgcMjqeVZSCCp5BFAGnRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFcNrHxGvf+EovNA8N+HpfEN5p6I+oSm6S2gti43JHvYEs5X5toGACMkZrua8q+F9/b6L46+JWj6hPHBqT6x/aiLMwUyWskEQRlz1VSjKSOhoAX4K6lJq3iL4jXc1jcabNJrUYe0ugvmRMLSAEHaSDyOCCQRgjrVrxN4tm03xloCaz4Ijkgk1QafputSXMEjRPIrfOq4LpuVDnp6GoPg3q1nrnif4k3thcJd2kmtoI5ozlHxaQqSD3GQeRweo4p3xk1Oz+2+A0+1wb4/FNqXXzFyuIps554oA9JvLuGwtZrq5lWC3hRpJJXOFRQMkk9gAK88sfipr2tWMesaT4D1C/8PSjzIbk3cMVzPF2lS3Yg4I5AZlJGOOa2Pipp8/ir4V+KbLSHFzdXWm3EUIhYN5jbD8gx3P3fxpngz4geG7z4faXrCatY2mnR2kYlaadIxbsFAZHyflKkEEH0oA1fGGratpWitPpOjtqtwQd0X2lIDEu0ndluDg44HrXG/A/xd4o8ReDPDUmr6LI0E9gkj6zLfRu0zbchjGBuyx/KvSL4fadNuBF+88yJtm053ZXjFcD8BdWsv8AhTvg6P7XCJFsorZkMgDCVRtaMj+8CCMdaAPR6KKKAPMPDOo2ukfFT4p3t7cR2lnbxabJLPMwVEUW7kkk9BXU+BfGUnjnT5tTi0q40/SnkxYz3Z2yXcf/AD1EeMoh/h3ckc4HFeQeLPAt/wCNviN4+bTZI57rTLjSb5dKvD/oeolIHPlTD07g9AcZB7ev+AvHlh480l7i2jksr21f7PfabcDbPZzDrG6/yPQjkUAYNx8UtT1C+1EeGfCN34j03Tpntri+W7it1klQ4kSBXOZCpyCflGQQCa0774lWa/DOfxrptpPqVjFam7Nuv7uXYpxKCD0ZMPkeqkV5V8H9B1SHwnPpTfEe/wBAv9Hu7mC+0sW9l/o7ec7b8yRFirhg4Ykg7uterfDrwvpmk+CBYWmqf8JHpt5JcXDXjmNluPOkZ5MeWAuCWbgDFAGj4m8aWHhrwTfeJ3b7RYW9obtPLPMw25RV92JAH1FV/FHjiPwj4VtdVv7C4a7uXgt4dNgKtLJcykKkIJIXO44ySBwTXj3hyWXVl8OfCm5kaWfQdYk/tANyX0+0Ky2pYf3X821X32t6V7D8QrXwxqmgppviq4trawvZ0iha4uPIPnj5k8t8ghwVyMHPFAFXRPFnia51a2tNX8Fz6ZbXBYLeW+oQ3KREKT+9A2sucYyobkgd6yfi5M2s6l4R8HbmW18QX7/bsHHmWsETSyRH2chFPsxHesT+1NS+HPjzwpodr4suPFWn61O9u+m6m0c15bII2fz1lQBigKgHeD165rY+Kg/sfxh8PfE0vFhp+pS2V1J2iW6iMSOx7KJPLBP+1QB6RHGsMaoiqiKAqqowAB0AFef+Lv8Aksnw9/69dV/9Agr0KvPfF3/JZPh7/wBeuq/+gQUAehVw3jTwTd+IviF4B1qHy/smh3F3Jc7mw2JICi7R3+bb+FdzRQBDeTSW9nPLFA91LGjMkEZAaQgZCgkgAnpyQOa8+n+KOtaDdWD+JvB0+iaTeXMdouoR6hFc+TJI22MSouCoLEDcCwBIrX+L3iq/8EfDbX9c0yJZr6zt98QkUsqksFLkDqFBLH2WvLPjJo9rovgTTru+8calrN5dX9g8S3F3GsF1/pMTM6xIoXaFBYY4GBzQB9B1wvwp8E3fglPFou/L/wCJr4ivNVh8ts/upSu3PHBwvSu6ooAKKzPE3iKx8I+H7/WdSkaKwsYWnmZVLEKB2A6moPBvi7TfHnhmw17SJHl069QvE0iFG4YqQQehDKR+FAG1RRRQBwvizwTd658UfAXiKHy/smhrqAuNzYb99CqJtGOeQal+Nn/JH/Gv/YHu/wD0U1drXFfGz/kj/jX/ALA93/6KagDmofi1qPh3wnp+s3vg/UIvCkMEIl1Jp4xPHHgL5xtvveX367scla9XilSeNJI2V43AZWU5BB6EV5V458YaLJ+z7qE0V9b3qX+itZWscMgdp55IfLSNQOS25gMDkYPpXoHg/TZ9H8I6JYXRzc2tjBBKc5+dY1Vv1BoA534U+CbvwSni0Xfl/wDE18RXmqw+W2f3UpXbnjg4XpXdUUUAeefB/wD13jv/ALGi8/8AQIq7XW9FsvEWkXml6jAt1Y3cTQzQuOGUjB//AF9q4r4P/wCu8d/9jRef+gRV39xcRWdvLPPIsMMSl3kc4VVAyST2AFAHD/BbWrzVPBbWeoztdajot9c6PPcOctKYJSiuT3JQISe5JrvK84+A9rK3gy81mWNof+Eg1W81mONxgrFNKTF+aBD+Nej0AFFFFABRRRQAUUUUAFFFFABRRRQBw2sfEa9/4Si80Dw34el8Q3mnoj6hKbpLaC2Ljcke9gSzlfm2gYAIyRmsT4K6lJq3iL4jXc1jcabNJrUYe0ugvmRMLSAEHaSDyOCCQRgjrSfC+/t9F8dfErR9Qnjg1J9Y/tRFmYKZLWSCIIy56qpRlJHQ1J8G9Ws9c8T/ABJvbC4S7tJNbQRzRnKPi0hUkHuMg8jg9RxQBY1rxZNZePfD8WteCI0E2oS6fpmtvcwyvGWjdiyqBvQOkZyOPQ16HeXcNhazXVzKsFvCjSSSucKigZJJ7AAV5r8WNUs/+Em+HK/a4N0XiIGQeYuUxa3AOeeOa3/irp9x4p+Ffimy0lvtNzd6bcRwCFt3mNsI2Ajufu/jQBj2PxU17WrGPWNJ8B6hf+HpR5kNybuGK5ni7SpbsQcEcgMykjHHNdD8QNa1jRvDNzcaPpLahP5EhfFykJtwEJ3/ADZ3EHsKp+DPiB4bvPh9pesJq1jaadHaRiVpp0jFuwUBkfJ+UqQQQfSug8SI154Z1RIB5zS2cojCc7iUOMeuaAOM+DfirxN4g8I+Gn1fQ5I4JtKt5m1eS+jla4YxKd5QDcC2Seelej1wfwX1ixm+EvglUvIGb+yrW32iQZ8xYVVkxn7wKkEdeDXeUAFc94d8YRa/rniLSWtntL3RblIZEdg3mRvGHjlHswLDHYoa6GvJ/iTrlv8ACzx5p3jS6Jj0i+sJtL1EjgeZGrT2zfU7Zox/vqKAO30HxfH4h8ReItMt7ZxDo0sVtJeFgUlmaMSMij1QMmfdvauc8QfEbxN4cjv7+fwFdSaJYl3muYtSgacwpnMqwg8jaC23cDjtnir3wv0S78MfD2CW9hMut3vm6rfoOGe5mJkdPwyEHsorzS3upfGHwTu/GPiHxrfwz31jO7WdncJbWsEhDBbYIF3MQcKQxLE59aAPcIW03xZodvP5cOo6ZexRzxiaMOkiMAynaw+hrhPhLZW+n+L/AIl29rBFbW8esxBIoUCIv+hwHgDgc1vfCGRZPhP4LZWDD+xbMZBz/wAsErB+HV7b2fj74nxTzxwSrqsExSRwpCGzhAbnscHn2oA6zxZ4uj8JyaEklu1x/aupxaam1gPLZ1dt59QNnT3o8SeLovDereHbGS3eZtZvTZI6sAIyInk3H1GIyPxrl/jVKlr/AMILczOsVvB4os2llc4VAUlQEnsNzKPxql8Ttc0+b4jfDTS47yKTUF1h53t0bcyR/ZJwGbH3ck8Z64OM4NAHV+NPHQ8L3WnabZabca5ruol/sunWzqhKIAXkd2O1EXI5PdgADUXhHx7PretXeh6xo03h7XreFbr7LJMk8c0Bbb5kci8MA3BBAIJHHNcL8RrC6t/jhoV63iW48KWmoaLJp1vfwxQOrXCzCQwkzIyqXUgjoT5eBXQ+GPCMUPxAj1G98dXHibWbCxkgFnMtqjRQyuhLMsKKcExrjPHFAF3VfiNqUnibU9D8N+G5NfudLEX26aW8S1hieRN6ICwJZtpBOBgZHOa6XwzrF5rWmeff6Pc6Hdq7RvaXTxucj+JWRiGU9jx9BXFa14V8N+IvFGq6poviyfw94lt9sGoTaTex8lFGwXELhkbaDgErnHGaufBnxlqHjLw7qb6jcW+oSadqlxp0eqWseyK/jj27Z1UEgZyQdpIypxQBV+G7DxV408ZeJ7ob5bXUJNBsQ3Igt4Nok2+heUuT67V9BXpNea/CIf2Lrvj3w9cfJdw65Nqcan+O3usSo49Ru8xfqlelUAee/BH/AJFjWP8AsYNV/wDSyWuq8U2Osalpf2bRdTi0e6kcB7yS389kj53bFJA39MFsgehrlfgj/wAixrH/AGMGq/8ApZLXfXFxFax+ZNKkKdN0jBR+ZoA8y+B1nLpd14806TUL7U1s9faJLjUJzNKw+zQMcsfck4AA54Feo15d8I9Us5PEvxGVbuBmk8RtsUSKS3+jW44555B/Ku+8TeIrHwj4fv8AWdSkaKwsYWnmZVLEKB2A6mgDTorF8G+LtN8eeGbDXtIkeXTr1C8TSIUbhipBB6EMpH4VtUAMlQyROiu0TMCA64yvuMgjP1FeQeNvhLonhnwJrWuJqWrJ4h0+ymvE1+bUpjcGZELBmG7YVJGNgXbg4Ar2FmCKWYhVAySegryS817T/jFqiwNqFrB4FsZw8hknVW1iZGyFAJ/491YZJP8ArCAB8oyQD0XwjqF3q3hPRb6/j8m+ubKGa4jxjbI0alhjtgk1yfjj/krHw1/66aj/AOkpr0CGaO4iWSJ1kjYZV0III9Qa8/8AHH/JWPhr/wBdNR/9JTQB6HXmpx4P+OFtb2/7vT/FlhNNLAv3ReW2zMoHYtE4B9fLU16VXmmrD/hIvj34fig+ePw3pd1dXTryEkuSkcUZ9GKxyNj0+ooA9LooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACsPxF4H8O+LpIH1zQtO1d4P9U17apKU5zgFgcD2rcooAqWGkWOlNMbKyt7MzFTKbeJU3lVCKWwOcKqqM9AoHasK++FngvU7ye7vPCGg3d3O5klnn0yB3kYnJZmK5JJ7muoooAo6PoeneHbBLHStPtdMskJK21nCsUaknJIVQAMmsi4+GvhK71o6vP4Y0ibVC283kllGZS394ttyT79a6WigArnh8O/Cy69/bY8OaUNY3+Z9u+xx+dv8A72/Gd3v1roaKAOS8Sax4zstUaLRPDOm6pYbVK3F1q7Wzlu42CF+nrmq+j6547udUt4tT8J6TY2DNia4g1ppnRfUJ5C7vpkV2tFAFaDTbS1vLm7htYYru62+fPHGFkl2jC72Ay2ASBnpUcOi6fb6pPqcVhax6lcIsc14kKiaRR0VnxkgdgTV2igDn9e+HvhfxVeR3es+HdL1W6jACzXlnHK4A7ZYE49ulatwDpekyiwshM1vCfIs4SsYcqvyxqThVzgDnAFW6KAOD8BeEb+LxHrfi/XrO1sdc1ZIrdbS1YSfZbeMHajSADe5JJY9OFA4Wux1TSbHXLGSy1Kyt9Qs5Bh7e6iWSNvqrAg1booAwPDvgHw14Qlkl0PQNN0mWQbXks7VInYehYDJHtWpq2k2evaXdadqFtHd2N1G0U0EgyrqRgg1booAxfCeh3fhvSRp9zqkurRwuVtp7hf3yw4G1JGz+8YcjfgEjGeck43jrwHqHijW9C1fStfOg3+lLcIkn2NLkOswQMCGIAxs/WuzooAo6HaXtjpVvBqN//al6gIlu/JEPmHJ52A4HGBx6VeoooAZLEk8bxyIskbgqyMMhgeoI7iub0/4X+D9JjvY7Pwto9rHeIYrlYrGNRKh6o2F5X26V09FADI40hjSONQkaAKqqMAAdAKfRRQBy3xQ0HU/FXw91/RtHeCPUNQtWtUe5YrGqv8rkkAn7pbt1xWj4Q8M2ngvwvpeh2Ixa6fbpbocYLbRyx9yck+5NbFFABRRRQAVBfWNtqVnPaXlvFd2s6GOWCdA6SKRgqynggjsanooA56D4d+FrXXP7ah8OaVFq2d325LOMTBvXdjOffrXQ0UUAFZHifTdW1TTlh0fWBod2JAxuTarcZXByu1iBySOfateigDlfh74LuPBOn6nFd6qdYvNQv5dQmujbrBl3CggKCQB8v61P4x8IHxpHaWN1evFom4tfWMaYN6BjbGz54jzncoGW4GQMg9HRQA2NFjRURQiKMBVGAB6CnUUUAFFFFABRRRQAUUUUAFFFFABRRRQBh+IvA/h3xdJA+uaFp2rvB/qmvbVJSnOcAsDge1aNhpFjpTTGysrezMxUym3iVN5VQilsDnCqqjPQKB2q3RQByt38KfBN/dTXNz4O0C4uZnaSWabS4GeRiclmJXJJJJJNb2k6PYeH9PisNLsbbTbGLPl2tpCsUSZJY4VQAMkk/UmrlFAHNXHw18JXetHV5/DGkTaoW3m8ksozKW/vFtuSffrXS0UUAc9B8O/C1rrp1qHw5pUWrlt/25LOMTbj1bdjOffrVHxDrXjWz1WWLRvDGmalp4C7Lm51hrd2OBnKCBsYOR15xXX0UAcZoet+ObrVbeLVfCulafp7E+bc2+stO6DBxhDAu7nA6jrXTatoun69Z/ZdTsbbUbXcr+RdwrKm4HIO1gRkHkGrtFABXPQ/Dvwtb662tR+HNKj1dmLm+WzjE249W3Yzk+vWuhooAqaXpVloljHZafaQWNnGWKW9vGI41yxY4UcDJJP41l694A8M+Kb2G81nw/pmqXcIwk15aRyuo9MsDx7Vv0UAVdS0uz1mwmsdQtIL6ymXbJb3EYkjcehUjBFZmj+BPDfh+GGLTNA02wjhm+0Rrb2kabJdrL5gwOG2sw3dcMR3rdooApaxoun+ILCSx1SxttRs5Pv291EssbfVWBFVfDvg/QvCFvJDoej2OkRSHLrZW6Rbz6ttAz+Na9FAHOa/8OfCviq8W71nw3pWqXSgAT3dnHI+B0BYjJHtW5Y2NtptpFa2dvFa2sS7Y4YECIg9Ao4AqeigDmvE3g0a1qmn6zYXbaVrtidkd4ib1lhJBeCVMjejYzjIKsAwIPXpaKKAPPvCvw513wnq0723i4vos2oXF++mNpseT50jSMnm7t3VuvtXZa1oOmeJLE2WradaapZswY297As0ZI6HawIyKv0UAcxp/wALvBmlXsN5ZeEdCs7uFg8Vxb6bCkkbDoVYLkH3FN+KGg6n4q+Huv6No7wR6hqFq1qj3LFY1V/lckgE/dLduuK6migDH8IeGbTwX4X0vQ7EYtdPt0t0OMFto5Y+5OSfcmtiiigBskaTRvHIiyRuCrKwyCD1BFcl/wAKe8Bf9CR4c/8ABTb/APxFdfRQBBY2NtpdnBaWdvFaWkCCOKCBAkcagYCqo4AA7CuFsfhzrsnjLRtd1vxb/bCaUZzBarpscAzLGUOWVsnAI7dq9BooAgvo7iWxuEtJkt7to2EM0kfmKjkfKxXI3AHBxkZ9RWR4P8I23g/T5YYpZb29upTcXt/cEGa6mIALtjgcAAKOFAAHAreooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAorxD9p74+zfBjQ7G10qBJte1Tf5DzDMcCLjc5Hc5IAH1J6YPzH8X7X46aH4dtvEvirWtUh0y6ZVKWl8Y1hLDKq8UZAXpjp7E5NexhctniIxnKSipbX3fojyMVmUMPKUYxcnHe2y9WfoXRX5Df8ACbeIFk8wa7qSyZzuF3ID/Oun8K/tFfETwbdLJY+LNSmjXrb307XMR9tsmQPwxXpzyCol7tRP5Hmwz6nJ+9Ta+Z+qVFeRfs2/HeP45eEbi5ntksta051ivYYyTGSwJV1zyA208diD1r12vmatKdGbpzVmj6SlVjWgqkHowooorI1CiiigAooooAKKK8q+O37QGm/Ae30aXUdLutTGptKqC1dV2eWEJzu9d4/KtadOdaahTV2zOpUhRi5zdkj1WivlO2/4KFeEnmUXHhnWoos8tG0LkfgWH86+gvhz8TPD3xW8OprXhy9+12m7y5EZSkkLgAlHU9DyPY5yCRW9bB18OuapBpGFHF0K75acrs6qiiiuM6worn/G/j3QPhxoZ1fxJqUel6d5iw+dIjPl2zhQqgkng9B2NW/C/ijS/Gmg2etaNdC90y8UvBcKjIHAJUnDAEcg9RV8kuXntp3I5483JfXsatFfIXib9sTxbovxxufBcOkaK+mx60umiZ45vOMZlCbsiTG7B9Me1fXtb18NUw6i6n2tUYUcTTxDkofZ0YUUUVynUFFFFABRRRQAUU2RvLRm67RmvlD/AIeGeGP+hV1b/v7F/jXVRwtbEX9lG9jmrYmlh7e1la59Y0V88+B/24vh74t1KKwvhf8AhuaVgqTajGn2fJ6AyIx2/VgAPWvYfiJ4i1Dwx4B1zWtFsRq2o2dnJcW1qoLCVguRwvJHfA5IHFKphq1KahUjZvuFPEUqsXOnK6R0tFfOH7Kfx88a/GHVtctfEukW8NnZwrJFfWtu8KiQtjym3MQSRkjHI2nOc19H0q9CeHqOnPdFUK0cRTVSGzCiiuT+IHxU8K/C22s7jxTrEekxXjskG+N5DIVALYCKTxkc9OR61jGMpvlirs1lKMFzSdkdZRVbTdQt9W061vrSTzrS6iWeGQAjcjAMpweRkEda+Vvgz+058RvHXxrTwxrPhm3tdMkkmW4hjtZUlsQqsVLuWI6gKcjknjHFdFLDVK0Zyj9nVnPVxMKMoRl9rY+sqKKK5TqCiiigAooooAKKKKACiiigAooooAKKK+Qbr9sbxbB8eH8ELpGinTF8R/2P55jm87yvtPlbs+ZjdjnpjPaurD4apieb2fTU5a+Jp4fl9p10Pr6iiiuU6gooooAKKKKACiiigAorG8ZeLNP8C+FtT1/VZDFp+nwNPKR9446Ko7sTgAepFeSfAP8AaM1f48Ta21r4Pj0mw06Li6l1IyCSdvuRY8oYBAJLDOOODmuiFCpOnKrFe6t2YSr04VFSb957I90or57+Ef7WkfxA+JVz4I13w03hbV42lhjDXvnh54yd8R+RdpwrEdc7SPTP0JSrUKmHly1FZhRrU68eam7oKKKKwNwooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKK83+Ovxnsfgr4Q/tOeH7ZqFw/k2Vnux5j4ySx7Ko6/gO9fDWvftafE/WNQluU8SSacjElbayhjSOMegypJ/Ek+9exg8rr4yPtI2Ue7PIxmaUMHLkldvsj2n9u/w5rGua94Rk0vS73UFitpw7Wlu8uw70xnaDivNvih8YPiv8VPBNt4a1PwpewWqsj3E1vpswe5ZOm7IwBnB47gVxbftQfFH/ocr7/vmP/4moW/ai+KWePGV9/3zH/8AE19XRwdajTpwlGMnDZ3f+R8rWxVKtUqTjKUVPdWX+ZwGteHdX8PiM6npd7polzsN3bvFux1xuAz1rIZq6rxx8VfFfxIW0XxLrVxqy2pYwCYKNm7G7GAOuB+VcgzV6sZT5ff38jzJRgn7m3mfZ3/BOds3Hj//AHbD+dxX2pXwn+wVcSW+k/EyWJ2jkWKwKspwR809fREfi7VoZA630xx2Y5H5GvwjjDinD5HmnsK9OUuZJ3VvTr6H6pw/l1TGYCM4NKza/E9korE8KeJF8RaeZCAlxGdsiDp7Eexrbr08Hi6OOoQxNB3hJXX9fma1acqM3TmrNBRRRXYZBRRRQAV8c/8ABRX/AJBvgT/rref+gw19jV8c/wDBRX/kG+BP+ut5/wCgw162Vf75D5/kzys0/wBzn8vzR47G3wtj/ZbX7Uto/wASGnYQeQX+0j/SOC+Pl2+Vn73tjnFb37KOn+LLzwD8VX8LX11p19DZW09tNbgEvPGZHEYBBBLIHX/gQ9q2P2fv2PtC+LXw80zxRqmvaha/aZZke0tEjGAkjJw7A9celfZfw7+G+gfCvw3Fofh2yFpZqxkdmbdJNIQMu7H7zHA+gAAwBivYxmOpUYzowblJyvrstdvTQ8jB4KrVlCtNKMVG2m7039dT5i/Yv+PniXx1421nw/4q1qbVmmsxc2bXAUFGjbDquAOqvn/gFcn8Svjt8QfF37RV54T8GeJLrTdPfU49Kt4oFQqrKRHJIcqcjcHbPoK5H4i29z+zH+1BNqmnw7bNZm1CzjxhWt51dWQD0Us6/wDABXU/sH+BZPE3xI1fxlfBpk0mIrHK/VrmbILZ7kJ5mf8AfFbzpUKanjVFcrirK3V+X3GMKtao4YJyfMpO7v0X9Mo/tveIPGsni6z0PW4Ra+Frcl9Jw6M13tVVeaQgk7ssRyFwDwOST1/7Idj8X11bwhcXDXX/AArHy7japng8rb5coX5c+Z/rcdv0qt/wUTjYa54JcqdjW10obsSGjyP1H516n+yl8YPB5+F/gvwn/bkI8SMktuNO2uZN4eR+wwBtGc5x+NYVKkv7Mg4QTvdPTbfX18zenCP9pTU5tWtbXfbT08j5C+MWsP4d/aY8RarFCtzJY+IDdLCxIEhSUMFOPXGK6z4gfFr4+/D3W7DVPEuqalocmog3FrbssX2dlBGV8oZUY3KCrDcMjPWsL4iRrN+1nqMbruR/FKKynuDOuRXu3/BRQD+xvA5xz9ou/wD0GKu9zh7TD0pQT5o9fTocChP2derGbXK+nqeu+G/2hbe4/ZxT4maraqksNswntYTgPcrIYQq5zgO+3HXAbvivlbRPir8e/j/rWqTeFb+6SOyUSyWumSRWsMCsTtTcxBYnBwCxJwa67S9Du9d/4J+3C2aNLJa3cl28a9TGl1lz9AuW+i1S/Yb+KvhbwDbeL7LxHq9roz3BguIZbt9iyqgkDKD3YblwvU5OOhrgp0YUKderTgpSUmkmr2V0d9StOvUo0qk3GLim2na7sdJ+y3+1X4i1zxpB4I8czfbZrpmitL+SMRzRzKCfKkwACDggHGd2Ac54yP2mP2gPG/w1+Pk1npGtzx6PZraTnTcL5Uo2KzoTjOG5B5715L8IYpPHn7U2k3ulRv5M/iB9UHGNkCytMc+nyjH44rU/ba/5OC1f/r1tf/RS11xwtBY5LlWsbtedzleJrPBN8z0lZP5Gj8Qvi58e7Kw0/wAa6ne6j4f0HVZA2ni18tIACCyLsGWwVBI8wZYDPNfWX7K/xg1D4yfDQ6hrAj/tiwumsrmWNQizEKrLJtHAJD4IHGVOAAQK4P8AbMhSH9mnRI0UKkd3ZBQOwELj+VVP+Cev/JN/Ev8A2Fv/AGilebiPZ18A6ygotOysehh/aUMcqTm5Jq+p9TXH+ok/3T/Kvy6/Zd8M6X4w+OnhnSNasYtR0y4+1ebbTDKPttZWXP0ZQfwr9Rbj/USf7p/lX5Z/s0+MtH8AfGzw5r2vXn2DSbT7T51x5bybN1tKi/KgLHLMo4Hepynm9hiOTe2n3MrNOX2+H5tr6/ej1f8AbS+A/hv4Zx6Fr3hiz/sy2vpZLa5s0dmjDhQyuu4nbkbgR04GAOc+j/B34l61N+xfr+owX0sWq+H47mytrzILqEVHj6/3VkCj2UV5J+1/+0Nonxgm0bSPDLTXGk6c7zy3k0RjE0rAKAqthgFGeSBkt0459f8AC/w/vfh5+w/4kttSha21DULG41GaBxho/MChFI7HYqZHYkjtXXUU/qlGOJ+LmW++/wDkctNx+t1pYf4eV7bbf5mf+xT8XvGPxG8YeIbTxLr1zq9vb2CyxRzBQEYyAZGAO1cj8bP2svGvij4h3HhT4ezyWFnFdmwheziV7m+lDbCQxB2qW+6Fwcck84Df+Cef/I+eKv8AsGp/6NFeRfC/WLf4RftC6ddeJVeKDR9UmgvGKFjGfnjL4HJwTu4544rb6vS+t1pcibilZfLsYfWKv1WlFzaUm7v59z6M+Cdj+0NpfxS0ex8W3OqReHpd817JemG7iMaqTs8xd2xmO0DBB5Poa8L/AGsvE3jXXPihNbeMbVNOFmrf2bZQsrIlszna+VY5ZtoJJOeOgAAr7l0z9pL4e694m0nw/pGvpq+qalJ5cMVnE7KuFLEsxAUDAPfPtXx5+3lGyfHGIspAfSbdlJ7jfIM/mD+VYYCpOpjE6lJRfL2t8zox1OFPCNU6jkr97/I9w/ZLsfi/b6xHL41a6Pg5tEX+zRNPA6bt0JiwqEsP3e/r+PNeU/s4/Hrx/wCLvjz4e0XWPE93f6XcS3Ky2sgTawWCVlzhc8FQfwr6h+CHxg8H+LvDfhnQNJ1yG91qHR4Wls41ffH5caK+7jAIYgdee2a+IP2Tf+Tl/C3/AF3u/wD0mmqKS9ssTKrTSaWmnlLUqo/ZPDRp1G03rr5x0Pev2tP2qNc8DeKH8GeD5ksb23jR7/UTGskis6hljjDAgfKVJbBPzADGOfK9c+JP7QHwOuNH1fxLqN8trqHzxQak8dzFLgAmN1BJjOCOMq3XHQ4539qzTLrwv+0hrl1eQs0NxPBfwluksZROnsCrL9VNeq/tsfGLwj8QPA/hax8O6xbavcNdm+cW7ZMMfllQHH8LEv8AdPPymuqjRp040KcKakpr3na/Tuc1arOpKvOdRxcHor26nsXib43zeMP2V9V8eeHZpNI1RbUBhGQzW06yqjqCRyOTgkchga+avAH7QHxu+ImmXHhLwzcT6xrTyNePqIWITxQBVUoGfCIu7ncectgGu08A6Jd6R+wT4vmukZE1CeS7gDcfu/MhjB+hMbGoP+Cd0at4k8ZyFRvW0t1DdwC75H6D8q54U6OHoV5qClyy0v8AI6J1KuIrUIObjzR1t8znvgn+018QvDPxY0/w54t1O61SyutQXTL201EBpbaRn8vcrY3Aqx5GSCAeM4I+qv2jpviRb+D7N/ho5/tRrtYrmOOGN5TEwI3KZPlXDYyfRs5GK+IfHIC/tc32Bj/irEP/AJMrXpf7cfxY8T23xCTwnZaldaZotvZxzPDayGP7S75JZyMFgBgBTxkE1dbCxrYmjKnFK6u9NPu+ZFHFOlh6sakm7Oy11+/5HP8AxC8QftC/BeLTtZ8R+I762iu5THH/AKXDcxiQDdsZBlegPbHBr6Y8CfGrUfiT+zJ4g8XDbYa/Y6bfJLJbjCrcRQsyyIDnGQUbHYkiviz4pfDzwT4P8B+GtR0fxqnibxNqQSW8tLd0aO2Qx5YMBllYMVXDEE4PA7fQv7NX/JmvxF/3NV/9Ikp4ylTlh4VOVX5krqPL17CwlWpGvOnd25W7N36dzyTwb+1z8UF0jVdEtrq48Qa9qbxJYXDQCaa2wH8wRxqvzs2VxkHG08V1994h+NegfAO68XahrniLSdUsdcaC5t9SgMchtXiiCSbZEyFEp2jHHzn0rD/YFt4pvjZfvJGrvDos7xsRyrebCuR74Zh+Jr7x8Y+F7Txt4V1bQb8ZtNRtpLaQ4yV3KRuHuDgj3ArLHV6OFxCpxpK2jehrgqFbFUHUlUd9Utf66nh/7KvxxuvF/wAHde1TxTqLXuoeHpZpLu4kwHNvs81WOMDtIv8AwCvIv2Zvi18SvjB8aYLe98S3h0K3EuoXlqoQRiMHCRg7ehdkHXOAa8J07xRrPwktviJ4NmVoZ9ShGl3Kr/DJFcLk+4Keav8AwOvr79gv4ff8I/8ADa/8T3Ee26124xESOfs8RKr9MuZPqAtXiqFLCUq1ay9+3L810/H7iMNWq4qpRo3fu35vk+v4fefT1fmTfKX/AGxpFHU+Of8A2/r9Nq/Kj4paff6t+0N4rsNL3HUrvxLdW9sFcITI9yyqAxIxyRzmuPJVzSqryOvOHyxpvzPc/jh+1J4r8Z/Ey28LfC2/nitoZvskc1kqs+oTk4JBIOEHQHoeWJxjHv8ArHizVf2efgTPrXizVpvFXiOJV3NMwCyXMhAWJMAYjXuepCse+B8RaM3iL9lH44WUmq2kct3p5UzRx/NHc20i4YxsQOqkgHsy4PQivq39siSP4gfs32mvaFL9u0xLy11Iyxc5gZXTJHsZFyO2DnpXRiMPTjOhRhFezdter+f9fgYYevUlCvWm37RX06L5Hh/g/wAZftBfHyTV9X8O67cR29i3zRWs0dpEGIJESD+I4/vE9snkV6Z+yz+0f4j+Jmpal4D8WXjf2tJaStY6tHGsc6sowysAApZQdwOB9w5zXzj8FPhv4W+IUF/FrfxIt/A17A4McN5EojnQj7wkaVFyDkbevQ/T6F/Zy+Bvg3wv8YrbUfD3xOtvF2oaXbTTTWdnY4jKOhiyZllZeDIDgZPH41042OHjCpBxSaWlotW+e2pzYOWIlOnNNtN63ktflucl8G/j18QdD/aEsPCfjbxDc39ob6XSbm3nVAomO5I2BCj/AJabMH0NdJ+2V+0B4n8F/ELTfDvhPW5tK+y2QmvDbhSXkkbKqcg9FVT/AMDrlf25PA8/gv4o6P430wGBdUVXaVB9y7g24b2yvln3Ksa5f4W2s/7R/wC1SNYvISbJrxtVuI25CW8OBEh9jiJD9aIUqFTlxziuVRd1bS6/phOrXp82CUnzOSs79P6se6/HD4w+NvgX8E/BNmb1rjxjrETG81S6jV2gYKryKFI27gZFUEgjCHjPI8j8Dax+0F400AeKfDHi+TXArMZdPiv4JJ4sMR89u/AzjIGMkEYFfTv7TVn8ONf0HStA+IOqnQzeySS6ZqCq2YpUChvm2lQMSDIbAP1AI+EviB4UX4LeKNPvPCXj/T9fEm6S31DQrrbPBtI4lCsdhOeBuOcGscvVOtRsoJTbb1jdM1x3tKNW7m3BJLSVmj6a/bR8R65pPwJ8HaJrVwkmt6pPG+pPCoRHaKLc6gDjHmOh/wCAivS/2NPC8Xhv4B6HMqBbjVJJr+dsfeLOUU/98IlfOv7UfiPVPH3wJ+EPifVF/wBMuEuFuXVdoeQhAHx0G4RlsDjnivqj9l+8jvvgF4KkiOVWy8o4/vI7I36qa4sTF08vjH+8728rnZhpKpj5S/uq34HyD+1hA/ww/aeg8Q6cvkyyi01pFTgb1Yq3/fTQkn13Gv0LgmS5gjmjO6ORQ6n1BGRX5/ft+3SXXxn0qGP5nh0SFHA67jNO2PyI/OvvfQ7V7HRdPtpP9ZDbxxt9QoB/lWeYe9hcPJ72f6GuB93E4iK2uv1L1FFFeCe4FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHwR+3n4invvilpmk+Yfs1hpqMsfYSSOxY/iFQfhXzIzV9A/tyWzW/xylkbpPp1vIv0G5f5qa+eHev1DL7RwlNLsfmWPvLF1G+4O/YVExr6z/ZZ+AHhvVvB3/CdeMbP+1IZp2i07TnOInCEqzuP4vmBGDx8p4ORXvj6d4ajwlv4M8NwxLwqDS4TgfXbXwufceZTkOI+q4huU+qSvY+iy7hrF5hSVaLST2ufmWzUyOOS4kWONGkkY4VVBJJ9AK/TJrPQB18IeHP8AwVw//E1Np99p+i3Hn6d4c0PT5+gmtdPjjcfiBXyUvFnJbaQn9y/zPajwXjL/ABo8z/ZX+GWp/C/4T69qmvWzaff+JJIRBZzDbKsMe7azL1Gd7HB7Y9a7l2q7q2tXWsT+ddSmRhwB0AHsKy5JK/nTi3iH/WTMnjFHlikkl1su5+p5PlqyzCqhe/c7f4V3B/tq6iz8rQFj+DL/AI16hXk/wo58RXHp9lb/ANDSvWK/X+A5OWSxv0lL8z5vO1bGP0QUUUV+hnghRRRQAV5r8aPgH4f+OkOkxa9ealaLprStD/Z0saFvMCg7t8b5+4MYx3r0qitKdSdKSnB2aM6lONWLhNXTOT+F/wAN9M+E3g208NaRPd3NhbPI6SXrq0pLuXOSqqOpPat3XtatfDeh6jq98zJZWFtJdTsqliI0UsxAHU4B4q/VDXtFtfEmh6jpF8jPZX9tJazqrFSY3UqwBHQ4J5ocuefNUd77go8kOWC22Pz1/a++Nnhf4ya5oA8MwTTLp0UqS6hNEYzNvKkIqnnC7SckdWOPf6//AGXPhrJ8L/g7pNjdwGDVb7OoXqMMMskmMKfQqgRSPUGoPBP7Jvw18C61Dqtlor3l9AweCTUJ2mWJhyGCH5cjsSCRjivYa9bF4ylOjHDYdPlXc8vCYSpCtLE12uZ9jg/i98F/Dnxq0GHTPEEc6G3kMttd2jhJoGIwdpIIIIxkEEHA7gGvP/hf+xv4R+F/i6y8SWup6tqGo2TM1utzJGIlLKVJIVAScMe+PavfKK8+GKrU6bpRk1F9DvlhqM6iqyj7y6nhesfse+DNa+IsvjOfU9dTVJNQXUjDHcQiDzA4fGDCW25HTdn3rq/jR8BfD/x0tdKg1681K0TTnkeI6dLGhYuFB3b0fP3R0xXpNFH1qvzRlzax28hfVaPLKPLpLfzOQ+Gfwv0n4V+CYPC2mSXN7psTSNnUGSR28xizBtqqCOT26V5B4s/YS+HviLVpb6xuNU0FZWLNaWMqGAZ67Q6Er9M4HYCvo6iiGKr05ucJtN7hPC0akVCcU0tjzf4Rfs/+EPgrFO2g2s0uoXC7JtSvnElw65ztyAAq5AOFAzgZzgVzPxS/ZH8H/Fzxhc+JNY1LXLa+njjjaOxnhSIBFCjAaJj0HrXt1FEcVXjUdVTfM+o3hqMqapOK5V0OE+J3wd0b4r+Cbbwtq9zf2+nwSxSrJZSIspMalVyWRhjBOeKi+DfwV0P4IaJfaXoV1qF3b3lx9pkbUJEdw20LgFEUYwo7V6BRUe3qez9lze72L9jT9p7W3vdxrqHVlPQjFfM3/Dvv4d/9BnxP/wCBVv8A/GK+m6KqjiKuHv7KVrk1sPSr29rG9jxj4ffsj/Dn4d6lDqNtps+rahAweG41aYTeWw5BCAKmR2O3I7V6Z428JWfjzwnqvh7UJJ4bLUYGt5ZLZgsiqepUkEA/UGtuipnXq1Jqc5NtDhQpU4uEIpJnk3wb/Zq8MfA/VtQ1HQr7Vrue9gFvIuozROoUMGyNka85HrVb4t/sr+CPjBqjatqEV1pesMoWS+02RUabAwPMVlZWIHGcA4AGeBWh8Yv2i/DHwRv9NtNfttTnlv4nliNhCjgBSAc7nXB5rs/AfjSx+InhHTPEemRzxWGoRmWJblQsgAYr8wBIHIPeumVTFxaxTbV9L9zmjTwsk8MknboeUfCz9jzwX8LfE1r4gt7rVNV1S0Ja3a8mURxEqVyFRVycE9SR7V0vxo/Z38LfHBbOXWjdWeo2amOG+sXVZNhOdjBlIZc89MjJwRk59RorJ4uvKoqrm+ZdTZYWhGm6SguV9Dxj4M/sseF/grr82t6Zf6nqGpSQNbb7yRNioxUnCqg5yo5JNUvh7+x74N+Gvjiw8VaZqeuz6hZNI8cd3cQtES6MhyFhU9HPfrivdKKbxmIk5NzfvaMSwlCKilBe7qjgvix8EfCnxm02G28RWbtNb5+z31q/l3EOeoVsEEH0YEd8Zryfw/8AsE/D7SdSjur6+1jWIY23C0uJkSNvZtiBj+BFfStef/GH42aD8EdKsNQ1+C/ngvZjBGLCJHYMF3c7nXjFXh8RikvY0ZPXoiK+Hwz/AH1aK06mx4x+HekeNPAN54PnWTTtGuIEttmn7I2ijUqVVMqVAG0Dp0rk/gx+zn4b+Bl5qlzoN9qt2+oRxxyjUZYnChCSNuyNP7x65rpPhX8UdI+L/hRfEGiRXcNi0zwBb2NUk3LjPCswxz612FYyqVqUZUG2l1XmaqnRquNZK76M8L1b9j3wZrHxGl8aTanrq6pJqA1Iwx3EIg8wOHxgwltuR03Z963fjT+zb4V+OE1pd6u13Yapap5Ud9Yuqu0eSdjhlIYAkkdCMnmvV6Kr63X5oy53eOwvqtDllHkVnufP2i/sR/DnSfDOqaVKuoX9xqCqjanPKn2iAKwYeThNqcqMnaSRkE4OK7jwP8BfD/gH4Z614G0+81KbSdWFwJ5rmWNp186IRvtKxhRhRxlTz69K9Jooni69RWnNvW/zCGFoU3eEEuh478H/ANlvwp8FPE9xruh6hrF1dzWjWbJqE0TxhGdHJASJTnKDv3PFdz8RviVoXwr8PrrXiK4ktdPadbfzI4mkO9gSOFBP8Jrqa5T4lfDPQ/ix4b/sPxBFNLYectwBBKY2DqCAcj/eNL2vtqqniG2uvew/ZexpOOHST6drn5zfFLV4f2g/j7cS+EdOkiGtXMNtbrIuGkIRUMzgZ2jClj6AZPOa/S7wn4btPB/hnStDsV22mnW0drFxgkIoGT7nGT7mvDdKb4Ffsw+LP7LjkFl4oniUF2huL652uflUFVYIW/ujBIIyORXofjT9oHwJ8O/EUOh+I9ZfStRmRJUSaznKFHOA28IVxkEE54wc4xXqY2pPFKnSowlyJaab+Z5mDpwwzqVK01zN667eR6LXhU37Hfgyf4lN43bU9dGqtqv9seSLiHyPO83zduPJ3bN3GN2cd+9e5o6yIrowZGGQynII9adXj061Sjf2btc9apRp1rc6vY8w+M37PHhX45NpsuuvfWl1YBljutNkSORkbkoxdGBXPI44JPqa0/hn8HNH+GPgy58K2t5qGtaJM0h+zay0UyorjDxgLGo2NySpB5J9a7yiq+sVXTVJy91dBewpKo6qj7z6nzX4j/YK+H2sahJdWF7q+ipI242tvMkkS+y70LD8WNd98Gf2b/CvwPury90WbULy/u4vIlub6ZWOzcG2hVVVHIHYnjrXq1FazxuIqQ9nObaMoYPD05+0jBJnxL+2B+0R4N8e+DT4S0eOfUNVg1EPJPNC0aWjRFlbBP3mOSvHGCTnpXZ/sFfDOXw94J1PxbfQGK51qQRWm8YP2aMn5h7M5P1CKe9d4v7HvwxbxFPrN1o9xfTzTtcPDc3chhLsxY/KCMjJ6HIr2a2tobO3it7eJIIIkEccUahVRQMBQBwAB2rurYyjHC/VcOnZ6ts4aOEqyxP1nENXW1jzz40fAbw78c7HToNdnvrV9PaRreaxlVGXeF3AhlYEfIvbtXlmi/sB+AtP1COe+1PWtUhRs/ZZJo40f2YogbH0Ir6borgp4zEUoezhNpHdUwdCrP2k4Js8X/aY+D6+O/gfcaHoVkiXWjCO702zgTA/dKV8pQPWMsAPXbXmf7B/xQtn8F6x4Q1K4W2uNHeS/g847R9mbmTr/cfJP/XQV9aUVccX/s8sPNXTd0+zIlhf9ojiIO1lZrufnp4b064/ag/auudXiheTw9b3q3UsjqQq2cBCxqfQybFGOuXY9jX6F0UUYvFfWXFJWjFWSHhcL9WUm3dyd2wooorgO4KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAPkL9vr4aXOpafpHjWxt2lFjGbK+ZBnZEWzGx9gzMM/wC0K+H2av2Xu7SC/tZba5hjuLeZSkkUihldSMEEHqK8c1T9jv4UateyXLeGjbPIcslreTRpn2UPgfQYFfUYDNoYeiqNVPTax8zjsqlXqurSa13uc18JcR/AX4fKowv2GRsD1MrEmttmre8QeFdN8D6HoWhaRC0Gm2MLxwRs5cqu7PUnJ5Jrm3fP0r+PONqntOIMVNdWv/SUfsGS03DAUoPogd8/SoWatTR9S0+xWX7dYfbd2Nvzldvr0q+fEXh//oX8j/rs1fO0MFQrU1OeKhBvo1O6+6DX4nrSqzhKypt+at+rOUkeoWbNeneE7XQPFTXQXRkg8jb1kY5zn39q6W38G6LayiSPToQ45BbLfzr63A8D4rMqMcTh8RB05dfe6Oz0cV1RwVs5pYeTpzptSXp/mc78LdAlsbWbUZ12G4AWJT12dc/j/Su8pOnA4FLX7xlOW0sowUMHSd1Hr3b1bPicViJYqtKtLqFFFFewcgUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFIzBQSTgDk0AfNPx4/a21f4U+PJfCmm+Dvt92sccsd1cTttnV1yCkaLkgHIzu6qeK5LwF+3xNdeJoNM8ZeG4dKtZZRC95aSODbEnGXjfJIHfBBA7HpXJ6l+1V8Q/iv8UI9I+HNlp+lT3bta2UzW0UlzLCu58ySSggDAZ9oGBz1PJ8U+Pdh4t034nalF44vrXUfE3lwtcz2ioFIMa7AQiKMhdvavs8Pl9GUVRrQSla/xO/rbb8T4+vj60W6tGbcb9lb0v/wD75/aT+Ot38CfD+j6jZ6VBqzX101uUmlMYUBC2QQDmvFfEX/BQjytJ0z+xPDMc2pyQB71ryZhDDLkgogAy477iR1xirf7djFvhP4CYnJNyCT/ANsKufsm+EdKuv2YfFU09jDPLqTXqXEkkYLMiwgKuT2HJHoSTXDRo4anhI16sOZ3tv5nbWrYmpi5UaU+VWvt5Hd/s3/tTW3xxvLzR77TF0fXrWH7QI4pS8VxGCAzLkZUgsMqc8HOeuMD9oH9siL4U+KpPDOgaTDrGp2oU3lxcylYYWIBEYC8s2CCTkAZxyc4+ev2HGI+PlkAcZsbkH/vkVzOtQW2oftV3kGvBWspvGLR3gm+4YjeYYHP8O39K6/7Pw8cXNNe6o3scn9oYiWEg0/ecrXLP7Q3x3h+O0fhm/fTjpep2EU8F1Ar74jlkKOjEA8/NwemOpr7m/ZZ/wCTf/Bf/Xo3/o16+cv+ChGkaPp+q+CpbO2t7bUZYbpJ/JRVZolMXl7sdgTIB+NfRv7LP/Jv/gv/AK9G/wDRr1zY6UJ5fSlTjZX2+86cFGcMfUjUd3bf7in+0l8atZ+Bug6VrOn6Hb6xY3Nw1rcNNM0ZhcrujxgHIIV/yHrWl8BvjVD8YvhxJ4mubeLS5bWeaC7hWQskWwBs5IHGxlP51rfG34fr8Tvhb4g8PBA1zcW5e1J7Tp88fPbLKAfYmvz7+Evxdm+Hvwy+J/hxmeK51ayjS1RuNkhcQzD2Plyk/wDbOubC4Wni8K1Be+mvuf8AX4HRicVUwuJTm/caf3r+vxPpX4S/tia38WvihYeGLHwraw2VxLIz3bXLlordAWLkbcZwAPqwrY+P/wC1hqnwh8bDwvp3hA6jdvBHcRXdxcEJMrZ+5GqknBDL1HKnjvXHf8E+/h39l0rXvGtzFiS6cabZsRz5a4aVh7Ftg/4Aa5XxR+1b48+I3xUXQ/h1ZWGnTSztY2Nw9tFLdTICTuaSQFVU4LbQOPU11PC0ZYuUKVNOEFrdtK/e5zLE1Y4WMqlRqU3pZJu3ax0Xg39vy5/4SSHT/GXheLTbN5BHLc2buHts/wATRuCWA74IOOgPStb/AIKEyLL4B8JujB0bUXKspyCDEea+Xv2hNP8AGWm/Ei4j8e39rqXiRraF5prNUC7NvyA7EUZAA7dMc19DftosW+BvwzJOSTESf+3UV1/VqNLEYerSVua+zutuhy/WKtXD16VV35bbqz36nT/st+KZPA/7JeteIIrdbqXTJL67WF2Kq5RQ20kdM4rf/Zu/ak1D46eLNS0e70G20pLSxN2JYZ2kLESIm3BA/vfpXCfBP/kxrxp/1w1P/wBFiuG/4J9XEcfxW12JnCySaM+xSeWxPFnFctbD06kMTVkveT0OmlXqU54anF+61qeo/FD9szVPh/8AFfU/CMPhqzvILO5igF1JcurMHVGzgL/tfpXsnxw+OOi/A3w1FqWpxyXt7dOY7LT4WCvOwALHJ+6oyMtg4yOCTXwN+0FqEGqftLeJJ7aRZYhqscW5TkbkCIw/BlI/CvTP+ChUly3xI8NRvu+xrpO6P08wzPvx74CfpV/2fRnPDxtbmV352SI+v1owryvfldl5as14/wBv7xSpXUJfAtqdFaTy96zSjJ/uiUqV3Y/2a+oPht8aPDvxM+Hsni+yla0sbVZDfRXH37Ro13OGx1wuGBHUEfSvjXQPB3x98dfBvT/D+l6fZ3vga7tk+zwq9gu5A+8HcWDhtwyc85zmvZv2U/gh4m8C+DvH2heONP8A7LsNYjjiULdwy5QxypKcozBTtZOtZY3D4SNJuNlJPZSu2vTua4PEYuVRKV3Frdq1nbv2OR1b9vbXNY1q4t/B/ggXtnFllNy0kszxg/fKRj5Oo7tj1r2D9n39o24+Mmj+IL3UvDraFHoiqbi5WfzInJDEgAqCCApJHPUc818n+K/gX8Vf2a9aufEWgT3Mmn26t/xOtIbcPJzk+dFyQvAJDApkdTivaPgz+0PqHxe+F3xH0nWLO3i8RWeiXN19ts4xGLtTCybnUdHBCDI4II4GOdMVhcO6HPhoJx01Td1r1X9ehnhsViFW5MRJp66WVn8/69Tyv9mOzn+NX7T1z4o1gecbYza1Ij8gOGCQoPZC6Ef9cxXs/wC354Ji1b4caX4mjQfbNIvBC746wTDBB+jrHj6n1rzr/gnj5f8AwmXi3OPN+wRbfXHmc/0r6C/bF8v/AIZz8W7/APp12/X7XDiliajp5nTjHZWXyf8Aw48PTU8tqSlu7v5r/hiD9jrxxN42+BulC6kM13pMr6XI7HJKxhWj/KN0H4V7dXyp/wAE9fM/4Vz4mznyv7VG303eSmf6V9V14mPgqeKqRj3PZwM3PDQk+wUUUVwHeFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBw/xM0+aa3tbtFLRRblfHbOMH6cV5w7V76yiRSrAMp4IPQ1z194A0e+ct5DQMeT5LYH5V+RcTcG4jMsXLHYOavK109NUraPXt1Pp8vzWnh6apVVouqPG5Hrt/CfibQtO8OzW17Gv2g53KYt3mjsM4/nW63wr0hjnzrse29f8A4mrVp8NdEtXDNDJOR2lfI/IYrwcp4Uz7LcT7anGndpr3ndWfkj0MVmeBxFPkk5d9NDH+E1s6pqdzsKQSsipnvjdn+Yr0GmQwx28axxIscajCqowAPpT6/YMly3+yMBTwXNzct9dtW23+Z8pjMR9aryrWtf8A4YKKKK9s4wooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACk68GlooA+Gtf/Ya8caD44k1DwPr9jaWKztLZXT3Uttc2oOcKSiHkA43KefQdKseMv2CfFOpx6feWPiuz1XW51d9XudYmlUPMTlTGwR2YYyCX5yM98D7dor2f7WxWjutPLf1PI/srDaqz18zwb9pL4C+IPjF4H8MaNot5ptrdaZKHme/lkRGHlbPlKoxPPqBWv8AAv4O618MfgxfeEdUubG41Kdrplls5HaEeYuFyWRT9eK9iori+t1XRVD7KdzsWFpqq632mrHyZ+zj+yX4v+EPxOtvEes6jolzYx200JjsZ5nky64HDRKMfjTf2jP2NdT+IXja48UeEb2xgmv8Ne2V87RjzAAPMRlU/eABIOOcnJzgfWtFdH9pYj23t762t8jn/s7D+x9hbS9/mfD2sfsEeK9R8NafOfFVle+KfMK3S3s0v2ZINo2LG+xnLAg9QAQ3GNvzfVnwX8FX3w5+F/h/w3qUtvPfafAYpZLVmaIkuzfKWVTjBHUCu1orLEY6tiYKFR6J3NaGCo4ebnTWrVgr4q+LX7DXibxV8Rte1nw3qOh2mkahcG6jgvZpkkRnAaQYWJhjeWxg9MV9q0VGGxVXCScqT3LxGFp4qKjUWxy3wu8DwfDX4faF4agKt/Z9ssckidJJT80jj/ecsfxr5J8ZfsPeM9P8fXGr+B9csbaye5a5tJpLmW2ubQkk7cop+7nAYHJx0Ffb9FVQxtbDzlOD1lvcitg6NeEYSXw7HxH4w/YM8V6xa6ffQeLbXV/Ek+99WudYnmCs3y7PLYI7NgZBL4zgHjoPW/2gv2ffEXxX+G/g/wAP6Re6Zb3uj7PtEl7LIsbbYQh2FY2J59QOK+gaK1lmOIlKEm9Y7adzNZfQjGUUtJb6njvwM+CN34D+C974H8US2d79te5Sc6fI7RmKZdpALIpzjPavmy9/YM8faP4jZtA8QaWbIORDfPcS28yoePmVUODj+6SK+9aKKeY16U5zi/i3Cpl9CrCMJL4dj4f1f9gHxFY6xpM+g+INMu7eKOKS8k1J5InacOS/lqkbDZjbjLZznNfRn7QHwD0z47eHbe1nuTpur2LM9lfqm/ZuA3I65GVbA75BAPqD6pRU1MwxFSUJylrHZlU8Bh6cZQUdJbnwtpf7I/xw8KxSabofjS30/TGYkrY6zdQRHPUlFQc+vBr6E+GXwQ1fwb8D/EHg3VNah1HV9YS88y+UOyI88XljJb5mxjOcDPpXstFOtmFaurStvfRCo4CjRd437bnwjJ+yD8bLKxl0a18X2z6NIpia3j1i5S3dDwQ0ezGMdRg17l+zl+y7F8HNJ1p9Zv4tV1fWIPstx9mUiGGHnKKWALZJySQOgGOCT75RVVsyr1oOm7JPey3Jo5fQozU1dtd2fnp+zJeT/BP9p658L6wfJNyZtFkd+AXLB4XHs5RAP+ugr2f9vzxxFpPw50vwzHIPter3YmdAeRBDySR7u0eP90+lex+NPgH4C+IXiGPXde0BbvV41RFu4rqe3fCnKk+W65I7E88AZ4FHjL4B+A/iF4gh1vxFoX9q6lCiRJJPeXG0Ihyq7BIFxkkkY5yc5zXXLHUKmJp4mad0tdt1t1OWOCr08PUw8GrN6b7Pfocj+xz4Hn8E/A7SzdRmG71eV9UkjYchXCrH+caIfxr2+mqqxqqqoVVGAoGAB6U6vGrVXWqSqPqz16NNUacaa6IKKKKxNgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigD//2Q==\n", 21 | "text/plain": [ 22 | "" 23 | ] 24 | }, 25 | "execution_count": 23, 26 | "metadata": { 27 | "image/jpeg": { 28 | "width": 500 29 | } 30 | }, 31 | "output_type": "execute_result" 32 | } 33 | ], 34 | "source": [ 35 | "from IPython.display import Image\n", 36 | "Image(\"C:\\\\Users\\\\deepali\\\\OneDrive\\\\Desktop\\\\python-dict-keys-and-values.jpg\",width=500)" 37 | ] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "metadata": {}, 42 | "source": [ 43 | "#### Characteristics of dictionaries\n", 44 | "* **Unordered**: The items in dictionaries are stored without any index value, which is typically a range of numbers. They are stored as Key-Value pairs, and the keys are their index, which will not be in any sequence.\n", 45 | "* **Unique**: As mentioned above, each value has a Key; the Keys in Dictionaries should be unique. If we store any value with a Key that already exists, then the most recent value will replace the old value.\n", 46 | "* **Mutable**: The dictionaries are collections that are changeable, which implies that we can add or remove items after the creation.\n" 47 | ] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "metadata": {}, 52 | "source": [ 53 | "## Creating a dictionary\n", 54 | "There are following three ways to create a dictionary.\n", 55 | "\n", 56 | "1. Using curly brackets: The dictionaries are created by enclosing the comma-separated Key: Value pairs inside the {} curly brackets. The colon ‘:‘ is used to separate the key and value in a pair.\n", 57 | "2. Using dict() constructor: Create a dictionary by passing the comma-separated key: value pairs inside the dict().\n", 58 | "3. Using sequence having each item as a pair (key-value)" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": 1, 64 | "metadata": {}, 65 | "outputs": [ 66 | { 67 | "name": "stdout", 68 | "output_type": "stream", 69 | "text": [ 70 | "{'Name': 'Deepali', 'Country': 'India', 'Telephone': 56789}\n", 71 | "{'Name': 'Deepali', 'Country': 'India', 'Telephone': 56789}\n", 72 | "{'Name': 'Harsh', 'Country': 'USA', 'Telephone': 11789}\n", 73 | "{'Name': 'Deepali', 10: 'Mobile'}\n", 74 | "{'Name': 'Deepali', 'Telephones': [1178, 2563, 4569]}\n" 75 | ] 76 | } 77 | ], 78 | "source": [ 79 | "# create a dictionary using {}\n", 80 | "person = {\"Name\": \"Deepali\", \"Country\": \"India\", \"Telephone\": 56789}\n", 81 | "print(person)\n", 82 | "\n", 83 | "# create a dictionary using dict()\n", 84 | "person = dict({\"Name\": \"Deepali\", \"Country\": \"India\", \"Telephone\": 56789})\n", 85 | "print(person)\n", 86 | "\n", 87 | "# create a dictionary from sequence having each item as a pair\n", 88 | "person = dict([(\"Name\", \"Harsh\"), (\"Country\", \"USA\"), (\"Telephone\", 11789)])\n", 89 | "print(person)\n", 90 | "\n", 91 | "# create dictionary with mixed keys keys\n", 92 | "# first key is string and second is an integer\n", 93 | "sample_dict = {\"Name\": \"Deepali\", 10: \"Mobile\"}\n", 94 | "print(sample_dict)\n", 95 | "\n", 96 | "# create dictionary with value as a list\n", 97 | "person = {\"Name\": \"Deepali\", \"Telephones\": [1178, 2563, 4569]}\n", 98 | "print(person)\n" 99 | ] 100 | }, 101 | { 102 | "cell_type": "markdown", 103 | "metadata": {}, 104 | "source": [ 105 | "### Empty Dictionary\n", 106 | "When we create a dictionary without any elements inside the curly brackets then it will be an empty dictionary." 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": 2, 112 | "metadata": {}, 113 | "outputs": [ 114 | { 115 | "name": "stdout", 116 | "output_type": "stream", 117 | "text": [ 118 | "\n" 119 | ] 120 | } 121 | ], 122 | "source": [ 123 | "emptydict = {}\n", 124 | "print(type(emptydict)) \n" 125 | ] 126 | }, 127 | { 128 | "cell_type": "markdown", 129 | "metadata": {}, 130 | "source": [ 131 | "Note:\n", 132 | "\n", 133 | "* A dictionary value can be of any type, and duplicates are allowed in that.\n", 134 | "* Keys in the dictionary must be unique and of immutable types like string, numbers, or tuples.\n", 135 | "\n", 136 | "## Accessing elements of a dictionary\n", 137 | "There are two different ways to access the elements of a dictionary.\n", 138 | "\n", 139 | "1. Retrieve value using the key name inside the [] square brackets\n", 140 | "2. Retrieve value by passing key name as a parameter to the get() method of a dictionary." 141 | ] 142 | }, 143 | { 144 | "cell_type": "code", 145 | "execution_count": 3, 146 | "metadata": {}, 147 | "outputs": [ 148 | { 149 | "name": "stdout", 150 | "output_type": "stream", 151 | "text": [ 152 | "Deepali\n", 153 | "56789\n" 154 | ] 155 | } 156 | ], 157 | "source": [ 158 | "# create a dictionary named person\n", 159 | "person = {\"Name\": \"Deepali\", \"Country\": \"India\", \"Telephone\": 56789}\n", 160 | "\n", 161 | "# access value using key name in []\n", 162 | "print(person['Name'])\n", 163 | "\n", 164 | "# get key value using key name in get()\n", 165 | "print(person.get('Telephone'))\n" 166 | ] 167 | }, 168 | { 169 | "cell_type": "markdown", 170 | "metadata": {}, 171 | "source": [ 172 | "As we can see in the output, we retrieved the value ‘Jessa’ using key ‘name” and value 1178 using its Key ‘telephone’." 173 | ] 174 | }, 175 | { 176 | "cell_type": "markdown", 177 | "metadata": {}, 178 | "source": [ 179 | "### Get all keys and values\n", 180 | "Use the following dictionary methods to retrieve all key and values at once\n", 181 | "\n" 182 | ] 183 | }, 184 | { 185 | "cell_type": "markdown", 186 | "metadata": {}, 187 | "source": [ 188 | "|Method |Description |\n", 189 | "| ----- | ---------- |\n", 190 | "|keys()|Returns the list of all keys present in the dictionary.\n", 191 | "|values()|Returns the list of all values present in the dictionary\n", 192 | "|items()|Returns all the items present in the dictionary. Each item will be inside a tuple as a key-value pair." 193 | ] 194 | }, 195 | { 196 | "cell_type": "code", 197 | "execution_count": 4, 198 | "metadata": {}, 199 | "outputs": [ 200 | { 201 | "name": "stdout", 202 | "output_type": "stream", 203 | "text": [ 204 | "dict_keys(['name', 'country', 'telephone'])\n", 205 | "\n", 206 | "dict_values(['Deepali', 'India', 1178])\n", 207 | "\n", 208 | "dict_items([('name', 'Deepali'), ('country', 'India'), ('telephone', 1178)])\n", 209 | "\n" 210 | ] 211 | } 212 | ], 213 | "source": [ 214 | "person = {\"name\": \"Deepali\", \"country\": \"India\", \"telephone\": 1178}\n", 215 | "\n", 216 | "# Get all keys\n", 217 | "print(person.keys())\n", 218 | "\n", 219 | "print(type(person.keys()))\n", 220 | "\n", 221 | "\n", 222 | "# Get all values\n", 223 | "print(person.values())\n", 224 | "print(type(person.values())) \n", 225 | "\n", 226 | "# Get all key-value pair\n", 227 | "print(person.items())\n", 228 | "print(type(person.items()))\n" 229 | ] 230 | }, 231 | { 232 | "cell_type": "markdown", 233 | "metadata": {}, 234 | "source": [ 235 | "## Iterating a dictionary\n", 236 | "We can iterate through a dictionary using a for-loop and access the individual keys and their corresponding values." 237 | ] 238 | }, 239 | { 240 | "cell_type": "code", 241 | "execution_count": 5, 242 | "metadata": {}, 243 | "outputs": [ 244 | { 245 | "name": "stdout", 246 | "output_type": "stream", 247 | "text": [ 248 | "key : value\n", 249 | "name : Deepali\n", 250 | "country : India\n", 251 | "telephone : 1178\n", 252 | "\n", 253 | "\n", 254 | "key : value\n", 255 | "name Deepali\n", 256 | "country India\n", 257 | "telephone 1178\n" 258 | ] 259 | } 260 | ], 261 | "source": [ 262 | "person = {\"name\": \"Deepali\", \"country\": \"India\", \"telephone\": 1178}\n", 263 | "\n", 264 | "# Iterating the dictionary using for-loop\n", 265 | "print('key', ':', 'value')\n", 266 | "for key in person:\n", 267 | " print(key, ':', person[key])\n", 268 | "\n", 269 | "print(\"\\n\")\n", 270 | "\n", 271 | "# using items() method\n", 272 | "print('key', ':', 'value')\n", 273 | "for key_value in person.items():\n", 274 | " # first is key, and second is value\n", 275 | " print(key_value[0], key_value[1])" 276 | ] 277 | }, 278 | { 279 | "cell_type": "markdown", 280 | "metadata": {}, 281 | "source": [ 282 | "### Find a length of a dictionary\n", 283 | "\n", 284 | "In order to find the number of items in a dictionary, we can use the len() function." 285 | ] 286 | }, 287 | { 288 | "cell_type": "code", 289 | "execution_count": 6, 290 | "metadata": {}, 291 | "outputs": [ 292 | { 293 | "name": "stdout", 294 | "output_type": "stream", 295 | "text": [ 296 | "3\n" 297 | ] 298 | } 299 | ], 300 | "source": [ 301 | "person = {\"name\": \"Deepali\", \"country\": \"India\", \"telephone\": 1178}\n", 302 | "\n", 303 | "# count number of keys present in a dictionary\n", 304 | "print(len(person)) \n" 305 | ] 306 | }, 307 | { 308 | "cell_type": "markdown", 309 | "metadata": {}, 310 | "source": [ 311 | "### Adding items to the dictionary\n", 312 | "We can add new items to the dictionary using the following two ways.\n", 313 | "\n", 314 | "* Using key-value assignment: Using a simple assignment statement where value can be assigned directly to the new key.\n", 315 | "* Using update() Method: In this method, the item passed inside the update() method will be inserted into the dictionary. The item can be another dictionary or any iterable like a tuple of key-value pairs." 316 | ] 317 | }, 318 | { 319 | "cell_type": "code", 320 | "execution_count": 7, 321 | "metadata": {}, 322 | "outputs": [ 323 | { 324 | "name": "stdout", 325 | "output_type": "stream", 326 | "text": [ 327 | "{'name': 'Deepali', 'country': 'India', 'telephone': 1178, 'weight': 50, 'height': 6}\n" 328 | ] 329 | } 330 | ], 331 | "source": [ 332 | "person = {\"name\": \"Deepali\", \"country\": \"India\", \"telephone\": 1178}\n", 333 | "\n", 334 | "# update dictionary by adding 2 new keys\n", 335 | "person[\"weight\"] = 50\n", 336 | "person.update({\"height\": 6})\n", 337 | "\n", 338 | "# print the updated dictionary\n", 339 | "print(person)\n" 340 | ] 341 | }, 342 | { 343 | "cell_type": "markdown", 344 | "metadata": {}, 345 | "source": [ 346 | "### Set default value to a key\n", 347 | "Using the setdefault() method default value can be assigned to a key in the dictionary. In case the key doesn’t exist already, then the key will be inserted into the dictionary, and the value becomes the default value, and None will be inserted if a value is not mentioned.\n", 348 | "\n", 349 | "In case the key exists, then it will return the value of a key." 350 | ] 351 | }, 352 | { 353 | "cell_type": "code", 354 | "execution_count": 8, 355 | "metadata": {}, 356 | "outputs": [ 357 | { 358 | "name": "stdout", 359 | "output_type": "stream", 360 | "text": [ 361 | "name : Deepali\n", 362 | "country : India\n", 363 | "telephone : 1178\n", 364 | "state : Texas\n", 365 | "zip : None\n" 366 | ] 367 | } 368 | ], 369 | "source": [ 370 | "person_details = {\"name\": \"Deepali\", \"country\": \"India\", \"telephone\": 1178}\n", 371 | "\n", 372 | "# set default value if key doesn't exists\n", 373 | "person_details.setdefault('state', 'Texas')\n", 374 | "\n", 375 | "# key doesn't exists and value not mentioned. default None\n", 376 | "person_details.setdefault(\"zip\")\n", 377 | "\n", 378 | "# key exists and value mentioned. doesn't change value\n", 379 | "person_details.setdefault('country', 'Canada')\n", 380 | "\n", 381 | "# Display dictionary\n", 382 | "for key, value in person_details.items():\n", 383 | " print(key, ':', value)" 384 | ] 385 | }, 386 | { 387 | "cell_type": "markdown", 388 | "metadata": {}, 389 | "source": [ 390 | "### Modify the values of the dictionary keys\n", 391 | "We can modify the values of the existing dictionary keys using the following two ways.\n", 392 | "\n", 393 | "* Using key name: We can directly assign new values by using its key name. The key name will be the existing one and we can mention the new value.\n", 394 | "* Using update() method: We can use the update method by passing the key-value pair to change the value. Here the key name will be the existing one, and the value to be updated will be new." 395 | ] 396 | }, 397 | { 398 | "cell_type": "code", 399 | "execution_count": 9, 400 | "metadata": {}, 401 | "outputs": [ 402 | { 403 | "name": "stdout", 404 | "output_type": "stream", 405 | "text": [ 406 | "Canada\n", 407 | "USA\n" 408 | ] 409 | } 410 | ], 411 | "source": [ 412 | "person = {\"name\": \"Deepali\", \"country\": \"India\"}\n", 413 | "\n", 414 | "# updating the country name\n", 415 | "person[\"country\"] = \"Canada\"\n", 416 | "# print the updated country\n", 417 | "print(person['country'])\n", 418 | "\n", 419 | "# updating the country name using update() method\n", 420 | "person.update({\"country\": \"USA\"})\n", 421 | "# print the updated country\n", 422 | "print(person['country'])\n" 423 | ] 424 | }, 425 | { 426 | "cell_type": "markdown", 427 | "metadata": {}, 428 | "source": [ 429 | "### Removing items from the dictionary\n", 430 | "There are several methods to remove items from the dictionary. Whether we want to remove the single item or the last inserted item or delete the entire dictionary, we can choose the method to be used.\n", 431 | "\n", 432 | "Use the following dictionary methods to remove keys from a dictionary.\n", 433 | "\n", 434 | "|Method|Description|\n", 435 | "|:---- | :-------- |\n", 436 | "|pop(key[,d])|Return and removes the item with the key and return its value. If the key is not found, it raises KeyError.\n", 437 | "|popitem()|Return and removes the last inserted item from the dictionary. If the dictionary is empty, it raises KeyError.\n", 438 | "|del key|The del keyword will delete the item with the key that is passed\n", 439 | "|clear()|Removes all items from the dictionary. Empty the dictionary\n", 440 | "|del dict_name|Delete the entire dictionary\n" 441 | ] 442 | }, 443 | { 444 | "cell_type": "code", 445 | "execution_count": 10, 446 | "metadata": {}, 447 | "outputs": [ 448 | { 449 | "name": "stdout", 450 | "output_type": "stream", 451 | "text": [ 452 | "('height', 6)\n", 453 | "{'name': 'Deepali', 'country': 'India', 'telephone': 2834, 'weight': 58}\n", 454 | "2834\n", 455 | "{'name': 'Deepali', 'country': 'India', 'weight': 58}\n", 456 | "{'name': 'Deepali', 'country': 'India'}\n", 457 | "{}\n" 458 | ] 459 | } 460 | ], 461 | "source": [ 462 | "person = {'name': 'Deepali', 'country': 'India', 'telephone': 2834, 'weight': 58, 'height': 6}\n", 463 | "\n", 464 | "# Remove last inserted item from the dictionary\n", 465 | "deleted_item = person.popitem()\n", 466 | "print(deleted_item) # output ('height', 6)\n", 467 | "# display updated dictionary\n", 468 | "print(person) \n", 469 | "\n", 470 | "# Remove key 'telephone' from the dictionary\n", 471 | "deleted_item = person.pop('telephone')\n", 472 | "print(deleted_item) # output 1178\n", 473 | "# display updated dictionary\n", 474 | "print(person) \n", 475 | "\n", 476 | "# delete key 'weight'\n", 477 | "del person['weight']\n", 478 | "# display updated dictionary\n", 479 | "print(person)\n", 480 | "\n", 481 | "# remove all item (key-values) from dict\n", 482 | "person.clear()\n", 483 | "# display updated dictionary\n", 484 | "print(person) # {}\n", 485 | "\n", 486 | "# Delete the entire dictionary\n", 487 | "del person" 488 | ] 489 | }, 490 | { 491 | "cell_type": "markdown", 492 | "metadata": {}, 493 | "source": [ 494 | "### Checking if a key exists\n", 495 | "In order to check whether a particular key exists in a dictionary, we can use the keys() method and in operator. We can use the in operator to check whether the key is present in the list of keys returned by the keys() method.\n", 496 | "\n", 497 | "In this method, we can just check whether our key is present in the list of keys that will be returned from the keys() method." 498 | ] 499 | }, 500 | { 501 | "cell_type": "code", 502 | "execution_count": 11, 503 | "metadata": {}, 504 | "outputs": [ 505 | { 506 | "name": "stdout", 507 | "output_type": "stream", 508 | "text": [ 509 | "country name is India\n" 510 | ] 511 | } 512 | ], 513 | "source": [ 514 | "person = {'name': 'Deepali', 'country': 'India', 'telephone': 2834, 'weight': 50, 'height': 6}\n", 515 | "\n", 516 | "# Get the list of keys and check if 'country' key is present\n", 517 | "key_name = 'country'\n", 518 | "if key_name in person.keys():\n", 519 | " print(\"country name is\", person[key_name])\n", 520 | "else:\n", 521 | " print(\"Key not found\")\n" 522 | ] 523 | }, 524 | { 525 | "cell_type": "markdown", 526 | "metadata": {}, 527 | "source": [ 528 | "### Join two dictionary\n", 529 | "We can add two dictionaries using the update() method or unpacking arbitrary keywords operator **." 530 | ] 531 | }, 532 | { 533 | "cell_type": "markdown", 534 | "metadata": {}, 535 | "source": [ 536 | "### Using update() method\n", 537 | "In this method, the dictionary to be added will be passed as the argument to the update() method and the updated dictionary will have items of both the dictionaries." 538 | ] 539 | }, 540 | { 541 | "cell_type": "code", 542 | "execution_count": 12, 543 | "metadata": {}, 544 | "outputs": [ 545 | { 546 | "name": "stdout", 547 | "output_type": "stream", 548 | "text": [ 549 | "{'Deepali': 25, 'Arun': 80, 'Meena': 55, 'Kelvin': 68, 'Harry': 50, 'Om': 66}\n" 550 | ] 551 | } 552 | ], 553 | "source": [ 554 | "dict1 = {'Deepali': 25, 'Arun': 80, 'Meena': 55}\n", 555 | "dict2 = {'Kelvin': 68, 'Harry': 50, 'Om': 66}\n", 556 | "\n", 557 | "# copy second dictionary into first dictionary\n", 558 | "dict1.update(dict2)\n", 559 | "# printing the updated dictionary\n", 560 | "print(dict1)\n" 561 | ] 562 | }, 563 | { 564 | "cell_type": "markdown", 565 | "metadata": {}, 566 | "source": [ 567 | "### Using **kwargs to unpack\n", 568 | "We can unpack any number of dictionary and add their contents to another dictionary using **kwargs. In this way, we can add multiple length arguments to one dictionary in a single statement." 569 | ] 570 | }, 571 | { 572 | "cell_type": "code", 573 | "execution_count": 13, 574 | "metadata": {}, 575 | "outputs": [ 576 | { 577 | "name": "stdout", 578 | "output_type": "stream", 579 | "text": [ 580 | "{'Deepali': 1, 'Arun': 2, 'Farhan': 5, 'Om': 6, 'Nancy': 7, 'Priya': 9}\n" 581 | ] 582 | } 583 | ], 584 | "source": [ 585 | "student_dict1 = {'Deepali': 1, 'Arun': 2, }\n", 586 | "student_dict2 = {'Farhan': 5, 'Om': 6}\n", 587 | "student_dict3 = {'Nancy': 7, 'Priya': 9}\n", 588 | "\n", 589 | "# join three dictionaries \n", 590 | "student_dict = {**student_dict1, **student_dict2, **student_dict3}\n", 591 | "# printing the final Merged dictionary\n", 592 | "print(student_dict)\n" 593 | ] 594 | }, 595 | { 596 | "cell_type": "markdown", 597 | "metadata": {}, 598 | "source": [ 599 | "### Add multiple dictionaries inside a single dictionary\n", 600 | "\n", 601 | "In this example, we will create a separate dictionary for each student and in the end, we will add each student to the ‘class_six’ dictionary. So each student is nothing but a key in a ‘class_six’ dictionary.\n", 602 | "\n", 603 | "In order to access the nested dictionary values, we have to pass the outer dictionary key, followed by the individual dictionary key.\n", 604 | "\n", 605 | "For example, class_six['student3']['name']\n", 606 | "\n", 607 | "We can iterate through the individual member dictionaries using nested for-loop with the outer loop for the outer dictionary and inner loop for retrieving the members of the collection." 608 | ] 609 | }, 610 | { 611 | "cell_type": "code", 612 | "execution_count": 14, 613 | "metadata": {}, 614 | "outputs": [ 615 | { 616 | "name": "stdout", 617 | "output_type": "stream", 618 | "text": [ 619 | "Student 3 name: Kelvin\n", 620 | "Student 3 marks: 85\n", 621 | "\n", 622 | "Class details\n", 623 | "\n", 624 | "student1\n", 625 | "Name : Deepali\n", 626 | "State : Maharashtra\n", 627 | "City : Mumbai\n", 628 | "Marks : 75\n", 629 | "\n", 630 | "\n", 631 | "student2\n", 632 | "Name : Emma\n", 633 | "State : Texas\n", 634 | "City : Dallas\n", 635 | "Marks : 60\n", 636 | "\n", 637 | "\n", 638 | "student3\n", 639 | "Name : Kelvin\n", 640 | "State : Texas\n", 641 | "City : Austin\n", 642 | "Marks : 85\n", 643 | "\n", 644 | "\n" 645 | ] 646 | } 647 | ], 648 | "source": [ 649 | "# each dictionary will store data of a single student\n", 650 | "Deepali = {'Name': 'Deepali', 'State': 'Maharashtra', 'City': 'Mumbai', 'Marks': 75}\n", 651 | "Emma = {'Name': 'Emma', 'State': 'Texas', 'City': 'Dallas', 'Marks': 60}\n", 652 | "kelvin = {'Name': 'Kelvin', 'State': 'Texas', 'City': 'Austin', 'Marks': 85}\n", 653 | "\n", 654 | "# Outer dictionary to store all student dictionaries (nested dictionaries)\n", 655 | "class_six = {'student1': Deepali, 'student2': Emma, 'student3': kelvin}\n", 656 | "\n", 657 | "# Get student3's name and mark\n", 658 | "print(\"Student 3 name:\", class_six['student3']['Name'])\n", 659 | "print(\"Student 3 marks:\", class_six['student3']['Marks'])\n", 660 | "\n", 661 | "# Iterating outer dictionary\n", 662 | "print(\"\\nClass details\\n\")\n", 663 | "for key, value in class_six.items():\n", 664 | " # Iterating through nested dictionary\n", 665 | " # Display each student data\n", 666 | " print(key)\n", 667 | " for nested_key, nested_value in value.items():\n", 668 | " print(nested_key, ':', nested_value)\n", 669 | " print('\\n')\n" 670 | ] 671 | }, 672 | { 673 | "cell_type": "markdown", 674 | "metadata": {}, 675 | "source": [ 676 | "### Dictionary comprehension\n", 677 | "Dictionary comprehension is one way of creating the dictionary where the values of the key values are generated in a for-loop and we can filter the items to be added to the dictionary with an optional if condition." 678 | ] 679 | }, 680 | { 681 | "cell_type": "code", 682 | "execution_count": 15, 683 | "metadata": {}, 684 | "outputs": [ 685 | { 686 | "name": "stdout", 687 | "output_type": "stream", 688 | "text": [ 689 | "{2: 4, 8: 64}\n" 690 | ] 691 | } 692 | ], 693 | "source": [ 694 | "# calculate the square of each even number from a list and store in dict\n", 695 | "numbers = [1, 3, 5, 2, 8]\n", 696 | "even_squares = {x: x ** 2 for x in numbers if x % 2 == 0}\n", 697 | "print(even_squares)\n", 698 | "\n" 699 | ] 700 | }, 701 | { 702 | "cell_type": "markdown", 703 | "metadata": {}, 704 | "source": [ 705 | "Here in this example, we can see that a dictionary is created with an input list (any iterable can be given), the numbers from the list being the key and the value is the square of a number.\n", 706 | "\n", 707 | "We can even have two different iterables for the key and value and zip them inside the for loop to create a dictionary." 708 | ] 709 | }, 710 | { 711 | "cell_type": "code", 712 | "execution_count": 16, 713 | "metadata": {}, 714 | "outputs": [ 715 | { 716 | "name": "stdout", 717 | "output_type": "stream", 718 | "text": [ 719 | "{'Deepali': 1178, 'Emma': 4020, 'Kelvin': 5786}\n" 720 | ] 721 | } 722 | ], 723 | "source": [ 724 | "telephone_book = [1178, 4020, 5786]\n", 725 | "persons = ['Deepali', 'Emma', 'Kelvin']\n", 726 | "\n", 727 | "telephone_Directory = {key: value for key, value in zip(persons, telephone_book)}\n", 728 | "print(telephone_Directory)" 729 | ] 730 | }, 731 | { 732 | "cell_type": "markdown", 733 | "metadata": {}, 734 | "source": [ 735 | "we are creating a telephone directory with separate tuples for the key which is the name, and the telephone number which is the value. We are zipping both the tuples together inside the for a loop.\n", 736 | "\n", 737 | "#### Python Built-in functions with dictionary\n", 738 | "max() and min()\n", 739 | "As the name suggests the max() and min() functions will return the keys with maximum and minimum values in a dictionary respectively. Only the keys are considered here not their corresponding values." 740 | ] 741 | }, 742 | { 743 | "cell_type": "code", 744 | "execution_count": 17, 745 | "metadata": {}, 746 | "outputs": [ 747 | { 748 | "name": "stdout", 749 | "output_type": "stream", 750 | "text": [ 751 | "Maximum Key 3\n", 752 | "Minimum Key 1\n" 753 | ] 754 | } 755 | ], 756 | "source": [ 757 | "dict = {1:'aaa',2:'bbb',3:'AAA'}\n", 758 | "print('Maximum Key',max(dict)) # 3\n", 759 | "print('Minimum Key',min(dict)) # 1" 760 | ] 761 | }, 762 | { 763 | "cell_type": "markdown", 764 | "metadata": {}, 765 | "source": [ 766 | "### all()\n", 767 | "When the built-in function all() is used with the dictionary the return value will be true in the case of all – true keys and false in case one of the keys is false.\n", 768 | "\n", 769 | "Few things to note here are\n", 770 | "\n", 771 | "* Only key values should be true\n", 772 | "* The key values can be either True or 1 or ‘0’\n", 773 | "* 0 and False in Key will return false\n", 774 | "* An empty dictionary will return true." 775 | ] 776 | }, 777 | { 778 | "cell_type": "code", 779 | "execution_count": 18, 780 | "metadata": {}, 781 | "outputs": [ 782 | { 783 | "name": "stdout", 784 | "output_type": "stream", 785 | "text": [ 786 | "All True Keys:: True\n", 787 | "One False Key False\n", 788 | "Empty Dictionary True\n", 789 | "With 0 in single quotes True\n" 790 | ] 791 | } 792 | ], 793 | "source": [ 794 | "#dictionary with both 'true' keys\n", 795 | "dict1 = {1:'True',1:'False'}\n", 796 | "\n", 797 | "#dictionary with one false key\n", 798 | "dict2 = {0:'True',1:'False'}\n", 799 | "\n", 800 | "#empty dictionary\n", 801 | "dict3= {}\n", 802 | "\n", 803 | "#'0' is true actually\n", 804 | "dict4 = {'0':False}\n", 805 | "\n", 806 | "print('All True Keys::',all(dict1))\n", 807 | "print('One False Key',all(dict2))\n", 808 | "print('Empty Dictionary',all(dict3))\n", 809 | "print('With 0 in single quotes',all(dict4))" 810 | ] 811 | }, 812 | { 813 | "cell_type": "markdown", 814 | "metadata": {}, 815 | "source": [ 816 | "### any()\n", 817 | "any() function will return true if dictionary keys contain anyone false which could be 0 or false." 818 | ] 819 | }, 820 | { 821 | "cell_type": "code", 822 | "execution_count": 19, 823 | "metadata": {}, 824 | "outputs": [ 825 | { 826 | "name": "stdout", 827 | "output_type": "stream", 828 | "text": [ 829 | "All True Keys:: True\n", 830 | "One False Key :: True\n", 831 | "Empty Dictionary :: False\n", 832 | "With 0 in single quotes :: True\n", 833 | "all false :: False\n" 834 | ] 835 | } 836 | ], 837 | "source": [ 838 | "#dictionary with both 'true' keys\n", 839 | "dict1 = {1:'True',1:'False'}\n", 840 | "\n", 841 | "#dictionary with one false key\n", 842 | "dict2 = {0:'True',1:'False'}\n", 843 | "\n", 844 | "#empty dictionary\n", 845 | "dict3= {}\n", 846 | "\n", 847 | "#'0' is true actually\n", 848 | "dict4 = {'0':False}\n", 849 | "\n", 850 | "#all false\n", 851 | "dict5 = {0:False}\n", 852 | "\n", 853 | "print('All True Keys::',any(dict1))\n", 854 | "print('One False Key ::',any(dict2))\n", 855 | "print('Empty Dictionary ::',any(dict3))\n", 856 | "print('With 0 in single quotes ::',any(dict4))\n", 857 | "print('all false :: ',any(dict5))" 858 | ] 859 | }, 860 | { 861 | "cell_type": "markdown", 862 | "metadata": {}, 863 | "source": [ 864 | "### When to use dictionaries?\n", 865 | "Dictionaries are items stored in Key-Value pairs that actually use the mapping format to actually store the values. It uses hashing internally for this. For retrieving a value with its key, the time taken will be very less as O(1).\n", 866 | "\n", 867 | "For example, consider the phone lookup where it is very easy and fast to find the phone number (value) when we know the name (key) associated with it.\n", 868 | "\n", 869 | "So to associate values with keys in a more optimized format and to retrieve them efficiently using that key, later on, dictionaries could be used." 870 | ] 871 | }, 872 | { 873 | "cell_type": "markdown", 874 | "metadata": {}, 875 | "source": [ 876 | "#### Summary of dictionary operations\n" 877 | ] 878 | }, 879 | { 880 | "cell_type": "raw", 881 | "metadata": {}, 882 | "source": [ 883 | "Assume d1 and d2 are dictionaries with following items.\n", 884 | "\n", 885 | "d1 = {'a': 10, 'b': 20, 'c': 30}\n", 886 | "d2 = {'d': 40, 'e': 50, 'f': 60}" 887 | ] 888 | }, 889 | { 890 | "cell_type": "markdown", 891 | "metadata": {}, 892 | "source": [ 893 | "|Operations | Description |\n", 894 | "|:------- |:------ |\n", 895 | "|dict({'a': 10, 'b': 20})|Create a dictionary using a dict() constructor.|\n", 896 | "|d2 = {}|Create an empty dictionary.|\n", 897 | "|d1.get('a')|Retrieve value using the key name a.|\n", 898 | "|d1.keys()|Returns a list of keys present in the dictionary.|\n", 899 | "|d1.values()|Returns a list with all the values in the dictionary.\n", 900 | "|d1.items()|Returns a list of all the items in the dictionary with each key-value pair inside a tuple.\n", 901 | "|len(d1)|Returns number of items in a dictionary.\n", 902 | "|d1['d'] = 40|Update dictionary by adding a new key.\n", 903 | "|d1.update({'e': 50, 'f': 60})|Add multiple keys to the dictionary.\n", 904 | "|d1.setdefault('g', 70)|Set the default value if a key doesn’t exist.\n", 905 | "|d1['b'] = 100|Modify the values of the existing key.\n", 906 | "|d1.pop('b')|Remove the key b from the dictionary.\n", 907 | "|d1.popitem()|Remove any random item from a dictionary.\n", 908 | "|d1.clear()|Removes all items from the dictionary.\n", 909 | "|'key' in d1.keys()|Check if a key exists in a dictionary.\n", 910 | "|d1.update(d2)|Add all items of dictionary d2 into d1.\n", 911 | "|d3= {**d1, **d2}|Join two dictionaries.\n", 912 | "|d2 = d1.copy()|Copy dictionary d1 into d2.\n", 913 | "|max(d1)|Returns the key with the maximum value in the dictionary d1\n", 914 | "|min(d1)|Returns the key with the minimum value in the dictionary d1|" 915 | ] 916 | } 917 | ], 918 | "metadata": { 919 | "kernelspec": { 920 | "display_name": "Python 3", 921 | "language": "python", 922 | "name": "python3" 923 | }, 924 | "language_info": { 925 | "codemirror_mode": { 926 | "name": "ipython", 927 | "version": 3 928 | }, 929 | "file_extension": ".py", 930 | "mimetype": "text/x-python", 931 | "name": "python", 932 | "nbconvert_exporter": "python", 933 | "pygments_lexer": "ipython3", 934 | "version": "3.8.3" 935 | } 936 | }, 937 | "nbformat": 4, 938 | "nbformat_minor": 4 939 | } 940 | -------------------------------------------------------------------------------- /12.OOPs (Object Oriented Programming) - Jupyter Notebook.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Deepali-Shinde/Python/db400ec388c40c75b5c0f4eb1c8befdbb0d45e8b/12.OOPs (Object Oriented Programming) - Jupyter Notebook.pdf -------------------------------------------------------------------------------- /13. Lambda functions - Jupyter Notebook.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Deepali-Shinde/Python/db400ec388c40c75b5c0f4eb1c8befdbb0d45e8b/13. Lambda functions - Jupyter Notebook.pdf -------------------------------------------------------------------------------- /14. Regular Expression [RegEx] - Part 1 - Jupyter Notebook.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Deepali-Shinde/Python/db400ec388c40c75b5c0f4eb1c8befdbb0d45e8b/14. Regular Expression [RegEx] - Part 1 - Jupyter Notebook.pdf -------------------------------------------------------------------------------- /15. RegEx - part 2 - Jupyter Notebook.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Deepali-Shinde/Python/db400ec388c40c75b5c0f4eb1c8befdbb0d45e8b/15. RegEx - part 2 - Jupyter Notebook.pdf -------------------------------------------------------------------------------- /16 . Numpy - Jupyter Notebook.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Deepali-Shinde/Python/db400ec388c40c75b5c0f4eb1c8befdbb0d45e8b/16 . Numpy - Jupyter Notebook.pdf -------------------------------------------------------------------------------- /17. Pandas_Part 1 - Jupyter Notebook.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Deepali-Shinde/Python/db400ec388c40c75b5c0f4eb1c8befdbb0d45e8b/17. Pandas_Part 1 - Jupyter Notebook.pdf -------------------------------------------------------------------------------- /18. Pandas Part 2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Deepali-Shinde/Python/db400ec388c40c75b5c0f4eb1c8befdbb0d45e8b/18. Pandas Part 2.pdf -------------------------------------------------------------------------------- /4. Type Conversion and Type Casting.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Casting: Type Conversion and Type Casting" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "#### In Python, we can convert one type of variable to another type. This conversion is called type casting or type conversion.\n", 15 | "\n", 16 | "In casting, we convert variables declared in specific data types to the different data types.\n", 17 | "\n", 18 | "Python performs the following two types of casting.\n", 19 | "\n", 20 | "1. Implicit casting: The Python interpreter automatically performs an implicit Type conversion, which avoids loss of data.\n", 21 | "2. Explicit casting: The explicit type conversion is performed by the user using built-in functions.\n", 22 | "\n", 23 | "To perform a type casting, we are going to use the following built-in functions\n", 24 | "\n", 25 | "1. int(): convert any type variable to the integer type.\n", 26 | "2. float(): convert any type variable to the float type.\n", 27 | "3. complex(): convert any type variable to the complex type.\n", 28 | "4. bool(): convert any type variable to the bool type.\n", 29 | "5. str(): convert any type variable to the string type.\n", 30 | "\n", 31 | "In type casting, data loss may occur because we enforce the object to a specific data type.\n", 32 | "\n" 33 | ] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "metadata": {}, 38 | "source": [ 39 | "## Int type conversion\n", 40 | "* In int type conversion, we use the int() function to convert variables of other types to int type. Variable can be of any type such as float, string, bool.\n", 41 | "\n", 42 | "While performing int type conversion, we need to remember the following points.\n", 43 | "\n", 44 | "* When converting string type to int type, a string must contain integral value only and should be base-10.\n", 45 | "* We can convert any type to int type, but we cannot perform complex to int type.\n", 46 | "\n", 47 | "### Casting float value to an integer" 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": 1, 53 | "metadata": {}, 54 | "outputs": [ 55 | { 56 | "name": "stdout", 57 | "output_type": "stream", 58 | "text": [ 59 | "\n", 60 | "Integer number: 3\n", 61 | "\n" 62 | ] 63 | } 64 | ], 65 | "source": [ 66 | "pi = 3.14 # float number\n", 67 | "print(type(pi))\n", 68 | "\n", 69 | "# converting float integer\n", 70 | "num = int(pi)\n", 71 | "print(\"Integer number:\", num)\n", 72 | "print(type(num))\n" 73 | ] 74 | }, 75 | { 76 | "cell_type": "markdown", 77 | "metadata": {}, 78 | "source": [ 79 | "### Casting Boolean value to an integer\n" 80 | ] 81 | }, 82 | { 83 | "cell_type": "code", 84 | "execution_count": 2, 85 | "metadata": {}, 86 | "outputs": [ 87 | { 88 | "name": "stdout", 89 | "output_type": "stream", 90 | "text": [ 91 | "\n", 92 | "Integer number 1: 1\n", 93 | "\n", 94 | "Integer number 2: 0\n", 95 | "\n" 96 | ] 97 | } 98 | ], 99 | "source": [ 100 | "flag_true = True\n", 101 | "flag_false = False\n", 102 | "print(type(flag_true))\n", 103 | "\n", 104 | "# converting boolean to integer\n", 105 | "num1 = int(flag_true)\n", 106 | "num2 = int(flag_false)\n", 107 | "\n", 108 | "print(\"Integer number 1:\", num1) \n", 109 | "# Output 1\n", 110 | "print(type(num1)) \n", 111 | "# Output class 'int'\n", 112 | "\n", 113 | "print(\"Integer number 2:\", num2)\n", 114 | "print(type(num2))\n" 115 | ] 116 | }, 117 | { 118 | "cell_type": "markdown", 119 | "metadata": {}, 120 | "source": [ 121 | "### Casting a string to an integer\n" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": 3, 127 | "metadata": {}, 128 | "outputs": [ 129 | { 130 | "name": "stdout", 131 | "output_type": "stream", 132 | "text": [ 133 | "\n", 134 | "Integer number 1: 225\n", 135 | "\n" 136 | ] 137 | } 138 | ], 139 | "source": [ 140 | "string_num = \"225\"\n", 141 | "print(type(string_num))\n", 142 | "\n", 143 | "# converting str to integer\n", 144 | "num1 = int(string_num)\n", 145 | "\n", 146 | "print(\"Integer number 1:\", num1)\n", 147 | "print(type(num1))\n" 148 | ] 149 | }, 150 | { 151 | "cell_type": "markdown", 152 | "metadata": {}, 153 | "source": [ 154 | "When converting string type to int type, a string must contain integral value only and should be base-10. If you try to convert " 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": 4, 160 | "metadata": {}, 161 | "outputs": [ 162 | { 163 | "name": "stdout", 164 | "output_type": "stream", 165 | "text": [ 166 | "\n" 167 | ] 168 | }, 169 | { 170 | "ename": "ValueError", 171 | "evalue": "invalid literal for int() with base 10: 'Score is 25'", 172 | "output_type": "error", 173 | "traceback": [ 174 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 175 | "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", 176 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[1;31m# ValueError: invalid literal for int() with base 10: 'Score is 25'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mnum\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mstring_num\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 6\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnum\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", 177 | "\u001b[1;31mValueError\u001b[0m: invalid literal for int() with base 10: 'Score is 25'" 178 | ] 179 | } 180 | ], 181 | "source": [ 182 | "string_num = 'Score is 25'\n", 183 | "print(type(string_num))\n", 184 | "\n", 185 | "# ValueError: invalid literal for int() with base 10: 'Score is 25'\n", 186 | "num = int(string_num)\n", 187 | "print(num)" 188 | ] 189 | }, 190 | { 191 | "cell_type": "markdown", 192 | "metadata": {}, 193 | "source": [ 194 | "### Float type conversion\n" 195 | ] 196 | }, 197 | { 198 | "cell_type": "markdown", 199 | "metadata": {}, 200 | "source": [ 201 | "In float type conversion we use a built-in function float() . This function converts variables of other types to float types.\n", 202 | "\n", 203 | "\n", 204 | "### Casting integer to float\n" 205 | ] 206 | }, 207 | { 208 | "cell_type": "code", 209 | "execution_count": 5, 210 | "metadata": {}, 211 | "outputs": [ 212 | { 213 | "name": "stdout", 214 | "output_type": "stream", 215 | "text": [ 216 | "\n", 217 | "Float number: 725.0\n", 218 | "\n" 219 | ] 220 | } 221 | ], 222 | "source": [ 223 | "num = 725\n", 224 | "print(type(num))\n", 225 | "\n", 226 | "# converting float to integer\n", 227 | "num1 = float(num)\n", 228 | "\n", 229 | "print(\"Float number:\", num1)\n", 230 | "print(type(num1))\n" 231 | ] 232 | }, 233 | { 234 | "cell_type": "markdown", 235 | "metadata": {}, 236 | "source": [ 237 | "### Casting Boolean to float\n" 238 | ] 239 | }, 240 | { 241 | "cell_type": "code", 242 | "execution_count": 6, 243 | "metadata": {}, 244 | "outputs": [ 245 | { 246 | "name": "stdout", 247 | "output_type": "stream", 248 | "text": [ 249 | "\n", 250 | "Float number 1: 1.0\n", 251 | "\n", 252 | "Float number 2: 0.0\n", 253 | "\n" 254 | ] 255 | } 256 | ], 257 | "source": [ 258 | "flag_true = True\n", 259 | "flag_false = False\n", 260 | "print(type(flag_true)) \n", 261 | "\n", 262 | "# converting boolean to float\n", 263 | "num1 = float(flag_true)\n", 264 | "num2 = float(flag_false)\n", 265 | "\n", 266 | "print(\"Float number 1:\", num1)\n", 267 | "print(type(num1))\n", 268 | "\n", 269 | "print(\"Float number 2:\", num2)\n", 270 | "print(type(num2))\n" 271 | ] 272 | }, 273 | { 274 | "cell_type": "markdown", 275 | "metadata": {}, 276 | "source": [ 277 | "### Casting string to float\n" 278 | ] 279 | }, 280 | { 281 | "cell_type": "code", 282 | "execution_count": 7, 283 | "metadata": {}, 284 | "outputs": [ 285 | { 286 | "name": "stdout", 287 | "output_type": "stream", 288 | "text": [ 289 | "\n", 290 | "Float number: 725.535\n", 291 | "\n" 292 | ] 293 | } 294 | ], 295 | "source": [ 296 | "string_num = \"725.535\"\n", 297 | "print(type(string_num))\n", 298 | "\n", 299 | "# converting str to float\n", 300 | "num1 = float(string_num)\n", 301 | "\n", 302 | "print(\"Float number:\", num1)\n", 303 | "print(type(num1))\n" 304 | ] 305 | }, 306 | { 307 | "cell_type": "markdown", 308 | "metadata": {}, 309 | "source": [ 310 | "While performing float type conversion, we need to remember some points.\n", 311 | "\n", 312 | "* We can convert any type to float type, but we cannot cast complex to float type.\n", 313 | "* While converting string type to float type, a string must contain an integer/decimal value of base-10.\n", 314 | "\n", 315 | "### Complex type conversion\n", 316 | "In complex type conversion, we use the built-in function complex() to convert values from other types to the complex type. Value can be any type including of int, float, bool, str.\n", 317 | "\n", 318 | "The complex function has the following two forms for conversion.\n", 319 | "\n", 320 | "* complex(x): To convert a value x into a complex type. In this form, the real value is x, and the imaginary value is 0.\n", 321 | "* complex(x, y): To convert the value x and y into a complex type. In this form, the real value is x, and the imaginary is y.\n", 322 | "\n", 323 | "### Casting integer type to complex type\n" 324 | ] 325 | }, 326 | { 327 | "cell_type": "code", 328 | "execution_count": 8, 329 | "metadata": {}, 330 | "outputs": [ 331 | { 332 | "name": "stdout", 333 | "output_type": "stream", 334 | "text": [ 335 | "\n", 336 | "Complex number: (135+0j)\n", 337 | "\n", 338 | "Complex number: (135+235j)\n", 339 | "\n" 340 | ] 341 | } 342 | ], 343 | "source": [ 344 | "r_num = 135\n", 345 | "print(type(r_num)) # class 'int'\n", 346 | "\n", 347 | "# converting int to complex(x)\n", 348 | "c_num = complex(r_num)\n", 349 | "\n", 350 | "print(\"Complex number:\", c_num)\n", 351 | "print(type(c_num))\n", 352 | "\n", 353 | "# converting int to complex(x, y)\n", 354 | "r_num, i_num2 = 135, 235\n", 355 | "c_num = complex(r_num, i_num2)\n", 356 | "\n", 357 | "print(\"Complex number:\", c_num)\n", 358 | "print(type(c_num)) # class 'complex'" 359 | ] 360 | }, 361 | { 362 | "cell_type": "markdown", 363 | "metadata": {}, 364 | "source": [ 365 | "### Casting float type to complex type\n" 366 | ] 367 | }, 368 | { 369 | "cell_type": "code", 370 | "execution_count": 9, 371 | "metadata": {}, 372 | "outputs": [ 373 | { 374 | "name": "stdout", 375 | "output_type": "stream", 376 | "text": [ 377 | "\n", 378 | "Complex number: (53.25+0j)\n", 379 | "\n", 380 | "Complex number: (53.25+350.75j)\n", 381 | "\n" 382 | ] 383 | } 384 | ], 385 | "source": [ 386 | "r_num = 53.250\n", 387 | "print(type(r_num)) # class 'float'\n", 388 | "\n", 389 | "# converting float to complex(x)\n", 390 | "c_num = complex(r_num)\n", 391 | "\n", 392 | "print(\"Complex number:\", c_num)\n", 393 | "print(type(c_num)) \n", 394 | "\n", 395 | "# converting float to complex(x, y)\n", 396 | "r_num, i_num2 = 53.250, 350.750\n", 397 | "c_num = complex(r_num, i_num2)\n", 398 | "\n", 399 | "print(\"Complex number:\", c_num)\n", 400 | "print(type(c_num))\n" 401 | ] 402 | }, 403 | { 404 | "cell_type": "markdown", 405 | "metadata": {}, 406 | "source": [ 407 | "### Casting Boolean type to complex type\n" 408 | ] 409 | }, 410 | { 411 | "cell_type": "code", 412 | "execution_count": 10, 413 | "metadata": {}, 414 | "outputs": [ 415 | { 416 | "name": "stdout", 417 | "output_type": "stream", 418 | "text": [ 419 | "\n", 420 | "Complex number: (1+0j)\n", 421 | "\n", 422 | "Complex number: 1j\n", 423 | "\n" 424 | ] 425 | } 426 | ], 427 | "source": [ 428 | "boolean_true = True\n", 429 | "print(type(boolean_true)) # class 'bool'\n", 430 | "\n", 431 | "# converting boolean to complex(x)\n", 432 | "c_num = complex(boolean_true)\n", 433 | "\n", 434 | "print(\"Complex number:\", c_num) \n", 435 | "# Output (1+0j)\n", 436 | "print(type(c_num))\n", 437 | "# class 'complex'\n", 438 | "\n", 439 | "# converting boolean to complex(x, y)\n", 440 | "r_bool, i_bool = False, True\n", 441 | "c_num = complex(r_bool, i_bool)\n", 442 | "\n", 443 | "print(\"Complex number:\", c_num)\n", 444 | "# Output 1j\n", 445 | "print(type(c_num))\n", 446 | "# class 'complex'" 447 | ] 448 | }, 449 | { 450 | "cell_type": "markdown", 451 | "metadata": {}, 452 | "source": [ 453 | "### Bool type conversion\n", 454 | "We use the built-in function bool() to convert values of other types to bool types. This function returns two values, either True or False.\n", 455 | "\n", 456 | "We can convert any type of values to bool type, and the output for all values will be True, Except 0, which is False.\n", 457 | "If you convert an empty string to a boolean it will be converted to boolean False.\n", 458 | "\n", 459 | "The bool True is 1 and False is 0. Every non-zero value is treated as True.\n", 460 | "\n", 461 | "### Casting integer to Boolean type" 462 | ] 463 | }, 464 | { 465 | "cell_type": "code", 466 | "execution_count": 11, 467 | "metadata": {}, 468 | "outputs": [ 469 | { 470 | "name": "stdout", 471 | "output_type": "stream", 472 | "text": [ 473 | "\n", 474 | "True\n", 475 | "False\n", 476 | "\n" 477 | ] 478 | } 479 | ], 480 | "source": [ 481 | "num1 = 10\n", 482 | "num2 = 0\n", 483 | "print(type(num1)) # class 'int'\n", 484 | "\n", 485 | "# Convert into to bool\n", 486 | "b1 = bool(num1)\n", 487 | "b2 = bool(num2)\n", 488 | "\n", 489 | "print(b1)\n", 490 | "print(b2)\n", 491 | "\n", 492 | "print(type(b1))\n" 493 | ] 494 | }, 495 | { 496 | "cell_type": "markdown", 497 | "metadata": {}, 498 | "source": [ 499 | "### Casting float to Boolean type\n" 500 | ] 501 | }, 502 | { 503 | "cell_type": "code", 504 | "execution_count": 12, 505 | "metadata": {}, 506 | "outputs": [ 507 | { 508 | "name": "stdout", 509 | "output_type": "stream", 510 | "text": [ 511 | "\n", 512 | "True\n", 513 | "False\n", 514 | "\n" 515 | ] 516 | } 517 | ], 518 | "source": [ 519 | "f_num1 = 25.35\n", 520 | "f_num2 = 0.0\n", 521 | "print(type(f_num1)) # class 'float'\n", 522 | "\n", 523 | "# Convert float into to bool\n", 524 | "b1 = bool(f_num1)\n", 525 | "b2 = bool(f_num2)\n", 526 | "\n", 527 | "print(b1)\n", 528 | "\n", 529 | "print(b2)\n", 530 | "\n", 531 | "print(type(b1))\n" 532 | ] 533 | }, 534 | { 535 | "cell_type": "markdown", 536 | "metadata": {}, 537 | "source": [ 538 | "### Casting string to Boolean type\n" 539 | ] 540 | }, 541 | { 542 | "cell_type": "code", 543 | "execution_count": 13, 544 | "metadata": {}, 545 | "outputs": [ 546 | { 547 | "name": "stdout", 548 | "output_type": "stream", 549 | "text": [ 550 | "\n", 551 | "True\n", 552 | "True\n", 553 | "True\n", 554 | "False\n", 555 | "\n" 556 | ] 557 | } 558 | ], 559 | "source": [ 560 | "s1 = \"False\"\n", 561 | "s2 = \"True\"\n", 562 | "s3 = \"812\"\n", 563 | "s4 = \"\"\n", 564 | "print(type(s1)) # class 'str'\n", 565 | "\n", 566 | "# Convert string into to bool\n", 567 | "b1 = bool(s1)\n", 568 | "b2 = bool(s2)\n", 569 | "b3 = bool(s3)\n", 570 | "b4 = bool(s4)\n", 571 | "\n", 572 | "print(b1) # True\n", 573 | "print(b2) # True\n", 574 | "print(b3) # True\n", 575 | "print(b4) # False\n", 576 | "print(type(b1)) # class 'bool'" 577 | ] 578 | }, 579 | { 580 | "cell_type": "markdown", 581 | "metadata": {}, 582 | "source": [ 583 | "### Casting complex type to Boolean type\n" 584 | ] 585 | }, 586 | { 587 | "cell_type": "code", 588 | "execution_count": 14, 589 | "metadata": {}, 590 | "outputs": [ 591 | { 592 | "name": "stdout", 593 | "output_type": "stream", 594 | "text": [ 595 | "\n", 596 | "True\n", 597 | "False\n", 598 | "\n" 599 | ] 600 | } 601 | ], 602 | "source": [ 603 | "c1 = 33 + 9j\n", 604 | "c2 = 0 + 0j\n", 605 | "print(type(c1)) # class 'complex'\n", 606 | "\n", 607 | "# Convert complex value into to bool\n", 608 | "b1 = bool(c1)\n", 609 | "b2 = bool(c2)\n", 610 | "\n", 611 | "print(b1) # True\n", 612 | "print(b2) # False\n", 613 | "print(type(b1)) # class 'bool'" 614 | ] 615 | }, 616 | { 617 | "cell_type": "markdown", 618 | "metadata": {}, 619 | "source": [ 620 | "### String type conversion\n", 621 | "In str type conversion, we use the built-in function str() to convert converts variables of other types to a string type. This function returns the string type of object (value).\n", 622 | "\n", 623 | "### Casting int to str type\n" 624 | ] 625 | }, 626 | { 627 | "cell_type": "code", 628 | "execution_count": 15, 629 | "metadata": {}, 630 | "outputs": [ 631 | { 632 | "name": "stdout", 633 | "output_type": "stream", 634 | "text": [ 635 | "\n", 636 | "15\n", 637 | "\n" 638 | ] 639 | } 640 | ], 641 | "source": [ 642 | "num = 15\n", 643 | "print(type(num)) # class 'int'\n", 644 | "\n", 645 | "# converting int to str type\n", 646 | "s1 = str(num)\n", 647 | "print(s1)\n", 648 | "print(type(s1))\n", 649 | "# Output class 'str'" 650 | ] 651 | }, 652 | { 653 | "cell_type": "markdown", 654 | "metadata": {}, 655 | "source": [ 656 | "### Casting float type to str type\n" 657 | ] 658 | }, 659 | { 660 | "cell_type": "code", 661 | "execution_count": 16, 662 | "metadata": {}, 663 | "outputs": [ 664 | { 665 | "name": "stdout", 666 | "output_type": "stream", 667 | "text": [ 668 | "\n", 669 | "75.35\n", 670 | "\n" 671 | ] 672 | } 673 | ], 674 | "source": [ 675 | "num = 75.35\n", 676 | "print(type(num)) # class 'float'\n", 677 | "\n", 678 | "# converting float to str type\n", 679 | "s1 = str(num)\n", 680 | "print(s1)\n", 681 | "print(type(s1))\n" 682 | ] 683 | }, 684 | { 685 | "cell_type": "markdown", 686 | "metadata": {}, 687 | "source": [ 688 | "### Casting complex type to str type\n" 689 | ] 690 | }, 691 | { 692 | "cell_type": "code", 693 | "execution_count": 17, 694 | "metadata": {}, 695 | "outputs": [ 696 | { 697 | "name": "stdout", 698 | "output_type": "stream", 699 | "text": [ 700 | "\n", 701 | "(15+5j)\n", 702 | "\n" 703 | ] 704 | } 705 | ], 706 | "source": [ 707 | "complex_num = 15 + 5j\n", 708 | "print(type(complex_num)) # class 'complex'\n", 709 | "\n", 710 | "# converting complex to str type\n", 711 | "s1 = str(complex_num)\n", 712 | "print(s1)\n", 713 | "\n", 714 | "print(type(s1))\n", 715 | "# class 'str'" 716 | ] 717 | }, 718 | { 719 | "cell_type": "markdown", 720 | "metadata": {}, 721 | "source": [ 722 | "### Casting bool type to str type\n" 723 | ] 724 | }, 725 | { 726 | "cell_type": "code", 727 | "execution_count": 18, 728 | "metadata": {}, 729 | "outputs": [ 730 | { 731 | "name": "stdout", 732 | "output_type": "stream", 733 | "text": [ 734 | "\n", 735 | "True\n", 736 | "False\n", 737 | "\n" 738 | ] 739 | } 740 | ], 741 | "source": [ 742 | "b1 = True\n", 743 | "b2 = False\n", 744 | "print(type(b1)) # class 'bool'\n", 745 | "\n", 746 | "# converting bool to str type\n", 747 | "s1 = str(b1)\n", 748 | "s2 = str(b2)\n", 749 | "print(s1)\n", 750 | "print(s2)\n", 751 | "print(type(s1)) # class 'str'" 752 | ] 753 | }, 754 | { 755 | "cell_type": "code", 756 | "execution_count": null, 757 | "metadata": {}, 758 | "outputs": [], 759 | "source": [] 760 | } 761 | ], 762 | "metadata": { 763 | "kernelspec": { 764 | "display_name": "Python 3", 765 | "language": "python", 766 | "name": "python3" 767 | }, 768 | "language_info": { 769 | "codemirror_mode": { 770 | "name": "ipython", 771 | "version": 3 772 | }, 773 | "file_extension": ".py", 774 | "mimetype": "text/x-python", 775 | "name": "python", 776 | "nbconvert_exporter": "python", 777 | "pygments_lexer": "ipython3", 778 | "version": "3.8.3" 779 | } 780 | }, 781 | "nbformat": 4, 782 | "nbformat_minor": 4 783 | } 784 | -------------------------------------------------------------------------------- /8.Python Tuples.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## What is Tuple in Python?" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Tuple data type in Python is a collection of various immutable Python objects separated by commas. Tuples are much similar to Python Lists, but they are syntactically different, i.e., in lists we use square brackets while in tuples we use parentheses. In this module, we will learn all about the tuple data type in order to get started with it." 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "Tuples are ordered collections of heterogeneous data that are unchangeable. Heterogeneous means tuple can store variables of all types.\n", 22 | "\n", 23 | "Tuple has the following characteristics\n", 24 | "\n", 25 | "* **Ordered**: Tuples are part of sequence data types, which means they hold the order of the data insertion. It maintains the index value for each item.\n", 26 | "* **Unchangeable**: Tuples are unchangeable, which means that we cannot add or delete items to the tuple after creation.\n", 27 | "* **Heterogeneous**: Tuples are a sequence of data of different data types (like integer, float, list, string, etc;) and can be accessed through indexing and slicing.\n", 28 | "* **Contains Duplicates**: Tuples can contain duplicates, which means they can have items with the same value." 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "metadata": {}, 34 | "source": [ 35 | "#### Creating a Tuple\n", 36 | "We can create a tuple using the two ways\n", 37 | "\n", 38 | "1. Using parenthesis (): A tuple is created by enclosing comma-separated items inside rounded brackets.\n", 39 | "2. Using a tuple() constructor: Create a tuple by passing the comma-separated items inside the tuple()." 40 | ] 41 | }, 42 | { 43 | "cell_type": "markdown", 44 | "metadata": {}, 45 | "source": [ 46 | "##### A tuple can have items of different data type integer, float, list, string, etc;\n", 47 | "\n" 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": 1, 53 | "metadata": {}, 54 | "outputs": [ 55 | { 56 | "name": "stdout", 57 | "output_type": "stream", 58 | "text": [ 59 | "(10, 20, 25.75)\n", 60 | "('Deepali', 'Nikita', 'Pooja')\n", 61 | "('Deepali', 30, 45.75, [25, 78])\n", 62 | "('Deepali', 30, 45.75, [23, 78])\n" 63 | ] 64 | } 65 | ], 66 | "source": [ 67 | "# create a tuple using ()\n", 68 | "# number tuple\n", 69 | "number_tuple = (10, 20, 25.75)\n", 70 | "print(number_tuple)\n", 71 | "# Output (10, 20, 25.75)\n", 72 | "\n", 73 | "# string tuple\n", 74 | "string_tuple = ('Deepali', 'Nikita', 'Pooja')\n", 75 | "print(string_tuple)\n", 76 | "# Output (''Deepali', 'Nikita', 'Pooja')\n", 77 | "\n", 78 | "# mixed type tuple\n", 79 | "sample_tuple = ('Deepali', 30, 45.75, [25, 78])\n", 80 | "print(sample_tuple)\n", 81 | "# Output ('Deepali', 30, 45.75, [25, 78])\n", 82 | "\n", 83 | "# create a tuple using tuple() constructor\n", 84 | "sample_tuple2 = tuple(('Deepali', 30, 45.75, [23, 78]))\n", 85 | "print(sample_tuple2)\n", 86 | "# Output ('Deepali', 30, 45.75, [23, 78])" 87 | ] 88 | }, 89 | { 90 | "cell_type": "markdown", 91 | "metadata": {}, 92 | "source": [ 93 | "### Packing and Unpacking\n" 94 | ] 95 | }, 96 | { 97 | "cell_type": "markdown", 98 | "metadata": {}, 99 | "source": [ 100 | "A tuple can also be created without using a tuple() constructor or enclosing the items inside the parentheses. It is called the variable “Packing.”\n", 101 | "\n", 102 | "\n", 103 | "In Python, we can create a tuple by packing a group of variables. Packing can be used when we want to collect multiple values in a single variable. Generally, this operation is referred to as tuple packing.\n", 104 | "\n", 105 | "Similarly, we can unpack the items by just assigning the tuple items to the same number of variables. This process is called “Unpacking.”" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 7, 111 | "metadata": {}, 112 | "outputs": [ 113 | { 114 | "name": "stdout", 115 | "output_type": "stream", 116 | "text": [ 117 | "(1, 2, 'hello')\n", 118 | "\n", 119 | "(1, 2, 'hello')\n" 120 | ] 121 | } 122 | ], 123 | "source": [ 124 | "# packing variable into tuple\n", 125 | "\n", 126 | "tup1 = 1,2,\"hello\"\n", 127 | "print(tup1)\n", 128 | "\n", 129 | "print(type(tup1))\n", 130 | "\n", 131 | "# unpacking variable into tuple\n", 132 | "\n", 133 | "a,b,c=tup1\n", 134 | "print(tup1)\n", 135 | "\n" 136 | ] 137 | }, 138 | { 139 | "cell_type": "markdown", 140 | "metadata": {}, 141 | "source": [ 142 | "As we can see in the above output, three tuple items are assigned to individual variables i, j, k, respectively.\n", 143 | "In case we assign fewer variables than the number of items in the tuple, we will get the value error with the message too many values to unpack" 144 | ] 145 | }, 146 | { 147 | "cell_type": "markdown", 148 | "metadata": {}, 149 | "source": [ 150 | "#### Length of a Tuple\n" 151 | ] 152 | }, 153 | { 154 | "cell_type": "markdown", 155 | "metadata": {}, 156 | "source": [ 157 | "We can find the length of the tuple using the len() function. This will return the number of items in the tuple.\n", 158 | "\n" 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": 8, 164 | "metadata": {}, 165 | "outputs": [ 166 | { 167 | "name": "stdout", 168 | "output_type": "stream", 169 | "text": [ 170 | "6\n" 171 | ] 172 | } 173 | ], 174 | "source": [ 175 | "tup = [\"p\",\"y\",\"t\",\"h\",\"o\",\"n\"]\n", 176 | "print(len(tup))" 177 | ] 178 | }, 179 | { 180 | "cell_type": "markdown", 181 | "metadata": {}, 182 | "source": [ 183 | "#### Iterating a Tuple\n", 184 | "We can iterate a tuple using a for loop " 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": 9, 190 | "metadata": {}, 191 | "outputs": [ 192 | { 193 | "name": "stdout", 194 | "output_type": "stream", 195 | "text": [ 196 | "1\n", 197 | "2\n", 198 | "3\n", 199 | "hi\n", 200 | "[4, 5, 6]\n" 201 | ] 202 | } 203 | ], 204 | "source": [ 205 | "# create a tuple\n", 206 | "tup1 = (1,2,3,\"hi\",[4,5,6])\n", 207 | "\n", 208 | "# iterate a tuple\n", 209 | "for i in tup1:\n", 210 | " print(i)" 211 | ] 212 | }, 213 | { 214 | "cell_type": "markdown", 215 | "metadata": {}, 216 | "source": [ 217 | "### Accessing items of a Tuple\n" 218 | ] 219 | }, 220 | { 221 | "cell_type": "markdown", 222 | "metadata": {}, 223 | "source": [ 224 | "Tuple can be accessed through indexing and slicing.\n", 225 | "\n", 226 | "* Using indexing, we can access any item from a tuple using its index number\n", 227 | "* Using slicing, we can access a range of items from a tuple" 228 | ] 229 | }, 230 | { 231 | "cell_type": "markdown", 232 | "metadata": {}, 233 | "source": [ 234 | "#### Indexing\n", 235 | "A tuple is an ordered sequence of items, which means they hold the order of the data insertion. It maintains the index value for each item.\n", 236 | "\n", 237 | "We can access an item of a tuple by using its index number inside the index operator [] and this process is called “Indexing”.\n", 238 | "\n", 239 | "###### Note:\n", 240 | "\n", 241 | "* As tuples are ordered sequences of items, the index values start from 0 to the tuple’s length.\n", 242 | "* Whenever we try to access an item with an index more than the tuple’s length, it will throw the 'Index Error'.\n", 243 | "* Similarly, the index values are always integer. If we give any other type, then it will throw Type Error." 244 | ] 245 | }, 246 | { 247 | "cell_type": "code", 248 | "execution_count": 10, 249 | "metadata": {}, 250 | "outputs": [ 251 | { 252 | "name": "stdout", 253 | "output_type": "stream", 254 | "text": [ 255 | "D\n", 256 | "E\n", 257 | "E\n", 258 | "P\n" 259 | ] 260 | } 261 | ], 262 | "source": [ 263 | "tup = [\"D\",\"E\",\"E\",\"P\",\"A\",\"L\",\"I\"]\n", 264 | "\n", 265 | "for i in range(4):\n", 266 | " print(tup[i])" 267 | ] 268 | }, 269 | { 270 | "cell_type": "markdown", 271 | "metadata": {}, 272 | "source": [ 273 | "As seen in the above example, we print the tuple’s first four items with the indexing.\n", 274 | "\n", 275 | "Note: If we mention the index value greater than the length of a tuple then it will throw an index error." 276 | ] 277 | }, 278 | { 279 | "cell_type": "code", 280 | "execution_count": 12, 281 | "metadata": {}, 282 | "outputs": [ 283 | { 284 | "ename": "IndexError", 285 | "evalue": "list index out of range", 286 | "output_type": "error", 287 | "traceback": [ 288 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 289 | "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)", 290 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0mtup\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m\"D\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m\"E\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m\"E\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m\"P\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m\"A\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m\"L\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m\"I\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtup\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m7\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 291 | "\u001b[1;31mIndexError\u001b[0m: list index out of range" 292 | ] 293 | } 294 | ], 295 | "source": [ 296 | "tup = [\"D\",\"E\",\"E\",\"P\",\"A\",\"L\",\"I\"]\n", 297 | "print(tup[7])" 298 | ] 299 | }, 300 | { 301 | "cell_type": "markdown", 302 | "metadata": {}, 303 | "source": [ 304 | "Also, if you mention any index value other than integer then it will throw Type Error.\n", 305 | "\n" 306 | ] 307 | }, 308 | { 309 | "cell_type": "code", 310 | "execution_count": 13, 311 | "metadata": {}, 312 | "outputs": [ 313 | { 314 | "ename": "TypeError", 315 | "evalue": "tuple indices must be integers or slices, not float", 316 | "output_type": "error", 317 | "traceback": [ 318 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 319 | "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", 320 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;31m# TypeError: tuple indices must be integers or slices, not float\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtuple1\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2.0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 321 | "\u001b[1;31mTypeError\u001b[0m: tuple indices must be integers or slices, not float" 322 | ] 323 | } 324 | ], 325 | "source": [ 326 | "tuple1 = ('P', 'Y', 'T', 'H', 'O', 'N')\n", 327 | "\n", 328 | "# TypeError: tuple indices must be integers or slices, not float\n", 329 | "print(tuple1[2.0])" 330 | ] 331 | }, 332 | { 333 | "cell_type": "markdown", 334 | "metadata": {}, 335 | "source": [ 336 | "#### Negative Indexing\n", 337 | "The index values can also be negative, with the last but the first items having the index value as -1 and second last -2 and so on.\n", 338 | "\n", 339 | "For example, We can access the last item of a tuple using tuple_name[-1].\n", 340 | "\n", 341 | "Let’s do two things here\n", 342 | "\n", 343 | "* Access tuple items using the negative index value\n", 344 | "* Iterate tuple using negative indexing" 345 | ] 346 | }, 347 | { 348 | "cell_type": "code", 349 | "execution_count": 14, 350 | "metadata": {}, 351 | "outputs": [ 352 | { 353 | "name": "stdout", 354 | "output_type": "stream", 355 | "text": [ 356 | "N\n", 357 | "O\n", 358 | "P, Y, T, H, O, N, " 359 | ] 360 | } 361 | ], 362 | "source": [ 363 | "tuple1 = ('P', 'Y', 'T', 'H', 'O', 'N')\n", 364 | "# Negative indexing\n", 365 | "# print last item of a tuple\n", 366 | "print(tuple1[-1]) # N\n", 367 | "# print second last\n", 368 | "print(tuple1[-2]) # O\n", 369 | "\n", 370 | "# iterate a tuple using negative indexing\n", 371 | "for i in range(-6, 0):\n", 372 | " print(tuple1[i], end=\", \") \n", 373 | "# Output P, Y, T, H, O, N," 374 | ] 375 | }, 376 | { 377 | "cell_type": "markdown", 378 | "metadata": {}, 379 | "source": [ 380 | "#### Slicing a tuple\n", 381 | "We can even specify a range of items to be accessed from a tuple using the technique called ‘Slicing.’ The operator used is ':'.\n", 382 | "\n", 383 | "We can specify the start and end values for the range of items to be accessed from the tuple. The output will be a tuple, and it includes the range of items with the index values from the start till the end of the range. The end value item will be excluded.\n", 384 | "\n", 385 | "We should keep in mind that the index value always starts with a 0.\n", 386 | "\n", 387 | "For easy understanding, we will be using an integer tuple with values from 0 to 9 similar to how an index value is assigned." 388 | ] 389 | }, 390 | { 391 | "cell_type": "code", 392 | "execution_count": 15, 393 | "metadata": {}, 394 | "outputs": [ 395 | { 396 | "name": "stdout", 397 | "output_type": "stream", 398 | "text": [ 399 | "(1, 2, 3, 4)\n" 400 | ] 401 | } 402 | ], 403 | "source": [ 404 | "tuple1 = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n", 405 | "\n", 406 | "# slice a tuple with start and end index number\n", 407 | "print(tuple1[1:5])\n", 408 | "# Output (1, 2, 3, 4)" 409 | ] 410 | }, 411 | { 412 | "cell_type": "markdown", 413 | "metadata": {}, 414 | "source": [ 415 | "As seen in the above output the values starting from 1 to 4 are printed. Here the last value in the range 5 is excluded.\n", 416 | "\n", 417 | "Note:\n", 418 | "\n", 419 | "* If the start value is not mentioned while slicing a tuple, then the values in the tuples start from the first item until the end item in the range. Again the end item in the range will be excluded.\n", 420 | "* Similarly, we can mention a slicing range without the end value. In that case, the item with the index mentioned in the start value of the range till the end of the tuple will be returned." 421 | ] 422 | }, 423 | { 424 | "cell_type": "code", 425 | "execution_count": 16, 426 | "metadata": {}, 427 | "outputs": [ 428 | { 429 | "name": "stdout", 430 | "output_type": "stream", 431 | "text": [ 432 | "(0, 1, 2, 3, 4)\n", 433 | "(6, 7, 8, 9, 10)\n" 434 | ] 435 | } 436 | ], 437 | "source": [ 438 | "tuple1 = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n", 439 | "\n", 440 | "# slice a tuple without start index\n", 441 | "print(tuple1[:5])\n", 442 | "# Output (0, 1, 2, 3, 4)\n", 443 | "\n", 444 | "# slice a tuple without end index\n", 445 | "print(tuple1[6:])\n", 446 | "# Output (6, 7, 8, 9, 10)" 447 | ] 448 | }, 449 | { 450 | "cell_type": "markdown", 451 | "metadata": {}, 452 | "source": [ 453 | "Similarly, we can slice tuple using negative indexing as well. The last but first item will have the index -1." 454 | ] 455 | }, 456 | { 457 | "cell_type": "markdown", 458 | "metadata": {}, 459 | "source": [ 460 | "Here we can see that the items with the negative indexes starting from -1 till -4 are printed excluding -5.\n", 461 | "\n", 462 | "#### Finding an item in a Tuple\n", 463 | "We can search for a certain item in a tuple using the index() method and it will return the position of that particular item in the tuple.\n", 464 | "\n", 465 | "The index() method accepts the following three arguments\n", 466 | "\n", 467 | "1. item – The item which needs to be searched\n", 468 | "2. start – (Optional) The starting value of the index from which the search will start\n", 469 | "3. end – (Optional) The end value of the index search" 470 | ] 471 | }, 472 | { 473 | "cell_type": "code", 474 | "execution_count": 17, 475 | "metadata": {}, 476 | "outputs": [ 477 | { 478 | "name": "stdout", 479 | "output_type": "stream", 480 | "text": [ 481 | "2\n" 482 | ] 483 | } 484 | ], 485 | "source": [ 486 | "tuple1 = (10, 20, 30, 40, 50)\n", 487 | "\n", 488 | "# get index of item 30\n", 489 | "position = tuple1.index(30)\n", 490 | "print(position)\n" 491 | ] 492 | }, 493 | { 494 | "cell_type": "markdown", 495 | "metadata": {}, 496 | "source": [ 497 | "#### Find within a range\n", 498 | "We can mention the start and end values for the index() method so that our search will be limited to those values." 499 | ] 500 | }, 501 | { 502 | "cell_type": "code", 503 | "execution_count": 18, 504 | "metadata": {}, 505 | "outputs": [ 506 | { 507 | "name": "stdout", 508 | "output_type": "stream", 509 | "text": [ 510 | "5\n" 511 | ] 512 | } 513 | ], 514 | "source": [ 515 | "tuple1 = (10, 20, 30, 40, 50, 60, 70, 80)\n", 516 | "# Limit the search locations using start and end\n", 517 | "# search only from location 4 to 6\n", 518 | "# start = 4 and end = 6\n", 519 | "# get index of item 60\n", 520 | "position = tuple1.index(60, 4, 6)\n", 521 | "print(position) \n" 522 | ] 523 | }, 524 | { 525 | "cell_type": "markdown", 526 | "metadata": {}, 527 | "source": [ 528 | "#### Checking if an item exists\n", 529 | "We can check whether an item exists in a tuple by using the in operator. This will return a boolean True if the item exists and False if it doesn’t." 530 | ] 531 | }, 532 | { 533 | "cell_type": "code", 534 | "execution_count": 19, 535 | "metadata": {}, 536 | "outputs": [ 537 | { 538 | "name": "stdout", 539 | "output_type": "stream", 540 | "text": [ 541 | "True\n", 542 | "False\n" 543 | ] 544 | } 545 | ], 546 | "source": [ 547 | "tuple1 = (10, 20, 30, 40, 50, 60, 70, 80)\n", 548 | "# checking whether item 50 exists in tuple\n", 549 | "print(50 in tuple1)\n", 550 | "# Output True\n", 551 | "print(500 in tuple1)\n", 552 | "# Output False" 553 | ] 554 | }, 555 | { 556 | "cell_type": "markdown", 557 | "metadata": {}, 558 | "source": [ 559 | "### Adding and changing items in a Tuple\n" 560 | ] 561 | }, 562 | { 563 | "cell_type": "markdown", 564 | "metadata": {}, 565 | "source": [ 566 | "A list is a mutable type, which means we can add or modify values in it, but tuples are immutable, so they cannot be changed.\n", 567 | "\n", 568 | "Also, because a tuple is immutable there are no built-in methods to add items to the tuple.\n", 569 | "\n", 570 | "If you try to modify the value you will get an error." 571 | ] 572 | }, 573 | { 574 | "cell_type": "markdown", 575 | "metadata": {}, 576 | "source": [ 577 | "###### As a workaround solution, we can convert the tuple to a list, add items, and then convert it back to a tuple. As tuples are ordered collection like lists the items always get added in the end." 578 | ] 579 | }, 580 | { 581 | "cell_type": "code", 582 | "execution_count": 20, 583 | "metadata": {}, 584 | "outputs": [ 585 | { 586 | "name": "stdout", 587 | "output_type": "stream", 588 | "text": [ 589 | "(1, 2, 3, 4, 5, 6)\n" 590 | ] 591 | } 592 | ], 593 | "source": [ 594 | "tup1 = (1,2,3,4,5)\n", 595 | "\n", 596 | "#coverting tuple into list\n", 597 | "a = list(tup1)\n", 598 | "a.append(6)\n", 599 | "\n", 600 | "# converting list back into tuple\n", 601 | "tup1=tuple(a)\n", 602 | "print(tup1)" 603 | ] 604 | }, 605 | { 606 | "cell_type": "markdown", 607 | "metadata": {}, 608 | "source": [ 609 | "#### Modify nested items of a tuple\n", 610 | "One thing to remember here, If one of the items is itself a mutable data type as a list, then we can change its values in the case of a nested tuple." 611 | ] 612 | }, 613 | { 614 | "cell_type": "markdown", 615 | "metadata": {}, 616 | "source": [ 617 | "For example, let’s assume you have the following tuple which has a list as its last item and you wanted to modify the list items." 618 | ] 619 | }, 620 | { 621 | "cell_type": "code", 622 | "execution_count": 21, 623 | "metadata": {}, 624 | "outputs": [ 625 | { 626 | "name": "stdout", 627 | "output_type": "stream", 628 | "text": [ 629 | "(5, 6, 7, [8, 9, 10])\n", 630 | "(5, 6, 7, [89, 9, 10])\n" 631 | ] 632 | } 633 | ], 634 | "source": [ 635 | "tup = (5,6,7,[8,9,10])\n", 636 | "print(tup)\n", 637 | "\n", 638 | "# modifing last item first value:\n", 639 | "tup[3][0] = 89\n", 640 | "print(tup)" 641 | ] 642 | }, 643 | { 644 | "cell_type": "code", 645 | "execution_count": 22, 646 | "metadata": {}, 647 | "outputs": [ 648 | { 649 | "name": "stdout", 650 | "output_type": "stream", 651 | "text": [ 652 | "(0, 10, 2, 3, 4, 5)\n" 653 | ] 654 | } 655 | ], 656 | "source": [ 657 | "tuple1 = (0, 1, 2, 3, 4, 5)\n", 658 | "\n", 659 | "# converting tuple into a list\n", 660 | "sample_list = list(tuple1)\n", 661 | "# modify 2nd item\n", 662 | "sample_list[1] = 10\n", 663 | "\n", 664 | "# converting list back into a tuple\n", 665 | "tuple1 = tuple(sample_list)\n", 666 | "print(tuple1) \n", 667 | "# Output (0, 10, 2, 3, 4, 5)" 668 | ] 669 | }, 670 | { 671 | "cell_type": "markdown", 672 | "metadata": {}, 673 | "source": [ 674 | "### Removing items from a tuple\n", 675 | "Tuples are immutable so there are no pop() or remove() methods for the tuple. We can remove the items from a tuple using the following two ways.\n", 676 | "\n", 677 | "1. Using del keyword\n", 678 | "2. By converting it into a list" 679 | ] 680 | }, 681 | { 682 | "cell_type": "markdown", 683 | "metadata": {}, 684 | "source": [ 685 | "##### Using del keyword\n", 686 | "The del keyword will delete the entire tuple." 687 | ] 688 | }, 689 | { 690 | "cell_type": "code", 691 | "execution_count": 26, 692 | "metadata": {}, 693 | "outputs": [ 694 | { 695 | "ename": "NameError", 696 | "evalue": "name 'a' is not defined", 697 | "output_type": "error", 698 | "traceback": [ 699 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 700 | "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", 701 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m6\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 702 | "\u001b[1;31mNameError\u001b[0m: name 'a' is not defined" 703 | ] 704 | } 705 | ], 706 | "source": [ 707 | "a = (2,3,4,5,6)\n", 708 | "del a\n", 709 | "print(a) #we are getting error when we try to access a deleted tuple." 710 | ] 711 | }, 712 | { 713 | "cell_type": "markdown", 714 | "metadata": {}, 715 | "source": [ 716 | "#### By converting it into a List\n" 717 | ] 718 | }, 719 | { 720 | "cell_type": "code", 721 | "execution_count": 27, 722 | "metadata": {}, 723 | "outputs": [ 724 | { 725 | "name": "stdout", 726 | "output_type": "stream", 727 | "text": [ 728 | "(0, 1, 3, 4, 5)\n" 729 | ] 730 | } 731 | ], 732 | "source": [ 733 | "tuple1 = (0, 1, 2, 3, 4, 5)\n", 734 | "\n", 735 | "# converting tuple into a list\n", 736 | "sample_list = list(tuple1)\n", 737 | "# reomve 2nd item\n", 738 | "sample_list.remove(2)\n", 739 | "\n", 740 | "# converting list back into a tuple\n", 741 | "tuple1 = tuple(sample_list)\n", 742 | "print(tuple1) \n", 743 | "# Output (0, 1, 3, 4, 5)" 744 | ] 745 | }, 746 | { 747 | "cell_type": "markdown", 748 | "metadata": {}, 749 | "source": [ 750 | "### Count the occurrence of an item in a tuple\n", 751 | " a tuple can contain duplicate items. To determine how many times a specific item occurred in a tuple, we can use the count() method of a tuple object.\n", 752 | "\n", 753 | "The count() method accepts any value as a parameter and returns the number of times a particular value appears in a tuple." 754 | ] 755 | }, 756 | { 757 | "cell_type": "code", 758 | "execution_count": 28, 759 | "metadata": {}, 760 | "outputs": [ 761 | { 762 | "name": "stdout", 763 | "output_type": "stream", 764 | "text": [ 765 | "3\n", 766 | "0\n" 767 | ] 768 | } 769 | ], 770 | "source": [ 771 | "tuple1 = (10, 20, 60, 30, 60, 40, 60)\n", 772 | "# Count all occurrences of item 60\n", 773 | "count = tuple1.count(60)\n", 774 | "print(count)\n", 775 | "# Output 3\n", 776 | "\n", 777 | "count = tuple1.count(600)\n", 778 | "print(count)\n", 779 | "# Output 0" 780 | ] 781 | }, 782 | { 783 | "cell_type": "markdown", 784 | "metadata": {}, 785 | "source": [ 786 | "### Concatenating two Tuples\n", 787 | "We can concatenate two or more tuples in different ways. One thing to note here is that tuples allow duplicates, so if two tuples have the same item, it will be repeated twice in the resultant tuple." 788 | ] 789 | }, 790 | { 791 | "cell_type": "markdown", 792 | "metadata": {}, 793 | "source": [ 794 | "#### Using the + operator\n", 795 | "We can add two tuples using the + operator. This is a very and straightforward method and the resultant tuple will have items from both the tuples." 796 | ] 797 | }, 798 | { 799 | "cell_type": "code", 800 | "execution_count": 29, 801 | "metadata": {}, 802 | "outputs": [ 803 | { 804 | "name": "stdout", 805 | "output_type": "stream", 806 | "text": [ 807 | "(1, 2, 3, 4, 5, 3, 4, 5, 6, 7)\n" 808 | ] 809 | } 810 | ], 811 | "source": [ 812 | "tuple1 = (1, 2, 3, 4, 5)\n", 813 | "tuple2 = (3, 4, 5, 6, 7)\n", 814 | "\n", 815 | "# concatenate tuples using + operator\n", 816 | "tuple3 = tuple1 + tuple2\n", 817 | "print(tuple3)\n", 818 | "# Output (1, 2, 3, 4, 5, 3, 4, 5, 6, 7)" 819 | ] 820 | }, 821 | { 822 | "cell_type": "markdown", 823 | "metadata": {}, 824 | "source": [ 825 | "#### Using the sum() function\n", 826 | "We can also use the Python built-in function sum to concatenate two tuples. But the sum function of two iterables like tuples always needs to start with Empty Tuple. " 827 | ] 828 | }, 829 | { 830 | "cell_type": "code", 831 | "execution_count": 30, 832 | "metadata": {}, 833 | "outputs": [ 834 | { 835 | "name": "stdout", 836 | "output_type": "stream", 837 | "text": [ 838 | "(1, 2, 3, 4, 5, 3, 4, 5, 6, 7)\n" 839 | ] 840 | } 841 | ], 842 | "source": [ 843 | "tuple1 = (1, 2, 3, 4, 5)\n", 844 | "tuple2 = (3, 4, 5, 6, 7)\n", 845 | "\n", 846 | "# using sum function\n", 847 | "tuple3 = sum((tuple1, tuple2), ())\n", 848 | "print(tuple3)\n", 849 | "# Output (1, 2, 3, 4, 5, 3, 4, 5, 6, 7)" 850 | ] 851 | }, 852 | { 853 | "cell_type": "markdown", 854 | "metadata": {}, 855 | "source": [ 856 | "#### Nested tuples\n", 857 | "Nested tuples are tuples within a tuple i.e., when a tuple contains another tuple as its member then it is called a nested tuple.\n", 858 | "\n", 859 | "In order to retrieve the items of the inner tuple we need a nested for loop\n", 860 | "\n" 861 | ] 862 | }, 863 | { 864 | "cell_type": "code", 865 | "execution_count": 31, 866 | "metadata": {}, 867 | "outputs": [ 868 | { 869 | "name": "stdout", 870 | "output_type": "stream", 871 | "text": [ 872 | "p\n", 873 | "tuple (1, 2, 3) element\n", 874 | "1,2,3,\n", 875 | "\n", 876 | "tuple (4, 5, 6) element\n", 877 | "4,5,6,\n", 878 | "\n", 879 | "tuple python element\n", 880 | "p,y,t,h,o,n,\n", 881 | "\n" 882 | ] 883 | } 884 | ], 885 | "source": [ 886 | "nest_tup = ((1,2,3),(4,5,6),\"python\")\n", 887 | "\n", 888 | "# access the first item of the third tuple\n", 889 | "print(nest_tup[2][0])\n", 890 | "\n", 891 | "# iterate a nested tuple\n", 892 | "for i in nest_tup:\n", 893 | " print(\"tuple\",i,\"element\")\n", 894 | " for j in i:\n", 895 | " print(j,end=\",\")\n", 896 | " print(\"\\n\")" 897 | ] 898 | }, 899 | { 900 | "cell_type": "markdown", 901 | "metadata": {}, 902 | "source": [ 903 | "### Use built-in functions with tuple\n", 904 | "##### min() and max()\n", 905 | "As the name suggests the max() function returns the maximum item in a tuple and min() returns the minimum value in a tuple.\n", 906 | "\n" 907 | ] 908 | }, 909 | { 910 | "cell_type": "code", 911 | "execution_count": 32, 912 | "metadata": {}, 913 | "outputs": [ 914 | { 915 | "name": "stdout", 916 | "output_type": "stream", 917 | "text": [ 918 | "zara\n", 919 | "abc\n", 920 | "22\n", 921 | "4\n" 922 | ] 923 | } 924 | ], 925 | "source": [ 926 | "tuple1 = ('xyz', 'zara', 'abc')\n", 927 | "# The Maximum value in a string tuple\n", 928 | "print(max(tuple1)) \n", 929 | "# Output zara\n", 930 | "\n", 931 | "# The minimum value in a string tuple\n", 932 | "print(min(tuple1))\n", 933 | "# Output abc\n", 934 | "\n", 935 | "tuple2 = (11, 22, 10, 4)\n", 936 | "# The Maximum value in a integer tuple\n", 937 | "print(max(tuple2))\n", 938 | "# Output 22\n", 939 | "# The minimum value in a integer tuple\n", 940 | "print(min(tuple2))\n", 941 | "# Output 4" 942 | ] 943 | }, 944 | { 945 | "cell_type": "markdown", 946 | "metadata": {}, 947 | "source": [ 948 | "Note: We can’t find the max() and min() for a heterogeneous tuple (mixed types of items). It will throw Type Error\n", 949 | "\n" 950 | ] 951 | }, 952 | { 953 | "cell_type": "code", 954 | "execution_count": 33, 955 | "metadata": {}, 956 | "outputs": [ 957 | { 958 | "ename": "TypeError", 959 | "evalue": "'>' not supported between instances of 'int' and 'str'", 960 | "output_type": "error", 961 | "traceback": [ 962 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 963 | "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", 964 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0mtuple3\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'a'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'e'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m11\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m22\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m15\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;31m# max item\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtuple3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 965 | "\u001b[1;31mTypeError\u001b[0m: '>' not supported between instances of 'int' and 'str'" 966 | ] 967 | } 968 | ], 969 | "source": [ 970 | "tuple3 = ('a', 'e', 11, 22, 15)\n", 971 | "# max item\n", 972 | "print(max(tuple3))" 973 | ] 974 | } 975 | ], 976 | "metadata": { 977 | "kernelspec": { 978 | "display_name": "Python 3", 979 | "language": "python", 980 | "name": "python3" 981 | }, 982 | "language_info": { 983 | "codemirror_mode": { 984 | "name": "ipython", 985 | "version": 3 986 | }, 987 | "file_extension": ".py", 988 | "mimetype": "text/x-python", 989 | "name": "python", 990 | "nbconvert_exporter": "python", 991 | "pygments_lexer": "ipython3", 992 | "version": "3.8.3" 993 | } 994 | }, 995 | "nbformat": 4, 996 | "nbformat_minor": 4 997 | } 998 | -------------------------------------------------------------------------------- /Day 1. Python introduction and Variables.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Python Roadmap " 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Python Programming\n", 15 | " 1. Basics to Advanced\n", 16 | " 2. Conditional and Control statements, Loops\n", 17 | " 3. Functions & Oops\n", 18 | "\n", 19 | "Essential Python Libraries\n", 20 | " 1. Numpy\n", 21 | " 2. Pandas\n", 22 | " 3. Matplotlib\n", 23 | " 4. Seaborn\n", 24 | "\n", 25 | "- File handling & DateTime\n", 26 | "- Regular Expressions\n", 27 | "- Web scraping" 28 | ] 29 | }, 30 | { 31 | "cell_type": "markdown", 32 | "metadata": {}, 33 | "source": [ 34 | "### Why we use jupyter notebook??? " 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "metadata": {}, 40 | "source": [ 41 | "Jupyter notebook, formerly known as the IPython(Interactive Python) notebook, is a flexible tool that helps you create readable analyses, as you can keep code, images, comments, formulae and plots together" 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "The name Jupyter is an indirect acronyum of the three core languages it was designed for: **JU**lia, **PYT**hon, and **R** and is inspired by the planet Jupiter." 49 | ] 50 | }, 51 | { 52 | "cell_type": "markdown", 53 | "metadata": {}, 54 | "source": [ 55 | "## Keyboard shortcuts " 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "1. **Command Mode (press Esc to unable)**\n", 63 | " > `Enter` - enter edit mode
\n", 64 | " > `shift` + `enter` - run cell , select below
\n", 65 | " > `ctrl` + `enter` - run cell
\n", 66 | " > `Alt` + `enter` - run cell, insert below
\n", 67 | " > `Y` - to code
\n", 68 | " > `M` - to markdown
\n", 69 | " > `R` - to raw
\n", 70 | " > `1` - to heading 1
\n", 71 | " > `23456` - to heading 23456
\n", 72 | " > `A`/`B` - insert above and below cell
\n", 73 | " > `X` - cut selected cell
\n", 74 | " > `C` - copy selected cell
\n", 75 | " > `shift` + `v` - paste cell above
\n", 76 | " > `v` - paste cell below
\n", 77 | " > `z` - undo last cell deletion
\n", 78 | " > `D` - delet selected cell
\n", 79 | " > `shift`+ `M` - merge cell below
\n", 80 | " > `ctrl` + `S` - save and checkpoint
\n", 81 | " > `L` - toggle line number
\n", 82 | " > `o` - toggle output
\n", 83 | " > `shift`+`o` - toggle output scrolling
\n", 84 | " > `Esc` - close pager
\n", 85 | " > `o` - restart kernel
\n", 86 | " > `space` - scroll down
\n", 87 | " > `shift` + `space` - scroll up
\n", 88 | " > `shift` - ignore
" 89 | ] 90 | }, 91 | { 92 | "cell_type": "markdown", 93 | "metadata": {}, 94 | "source": [ 95 | "2. **Edit Mode (press Enter to enable)**\n", 96 | "> `tab` - code completion or indent
\n", 97 | "> `shift`+`tab`- tooltip
\n", 98 | "> `ctrl` + `]` - indent
\n", 99 | "> `ctrl` + `[` - denent
\n", 100 | "> `ctrl` + `A` - select all
\n", 101 | "> `ctrl` + `shift` + `z` - redo
\n", 102 | "> `ctrl` + `y` - redo
\n", 103 | "> `ctrl` + `Home` - go to cell start
\n", 104 | "> `ctrl` + `up` - go to cell start
\n", 105 | "> `ctrl` + `End` - go to cell end
\n", 106 | "> `ctrl` + `Down` - go to cell end
\n", 107 | "> `ctrl` + `left` - go one word left
\n", 108 | "> `ctrl` + `right` - go one word right
\n", 109 | "> `ctrl` + `backspace` - delet word before
\n", 110 | "> `ctrl` + `delet` - delet word after
\n", 111 | "> `ctrl` + `M` - command mode
\n", 112 | "> `ctrl`+`shift`+`minus` - split cell
\n", 113 | "> `ctrl`+ `/` - toggle comment on current or selected lines
\n", 114 | "\n" 115 | ] 116 | }, 117 | { 118 | "cell_type": "markdown", 119 | "metadata": {}, 120 | "source": [ 121 | "## Python variables" 122 | ] 123 | }, 124 | { 125 | "cell_type": "markdown", 126 | "metadata": {}, 127 | "source": [ 128 | "A variable is a reserved memory area (memory address) to store value. For example, we want to store an employee’s salary. In such a case, we can create a variable and store salary using it. Using that variable name, you can read or modify the salary amount.\n", 129 | "\n", 130 | "In other words, a variable is a value that varies according to the condition or input pass to the program. Everything in Python is treated as an object so every variable is nothing but an object in Python.\n", 131 | "\n", 132 | "A variable can be either mutable or immutable. If the variable’s value can change, the object is called mutable, while if the value cannot change, the object is called immutable." 133 | ] 134 | }, 135 | { 136 | "cell_type": "markdown", 137 | "metadata": {}, 138 | "source": [ 139 | "## Creating a variable" 140 | ] 141 | }, 142 | { 143 | "cell_type": "markdown", 144 | "metadata": {}, 145 | "source": [ 146 | "Python programming language is dynamically typed, so there is no need to declare a variable before using it or declare the data type of variable like in other programming languages. The declaration happens automatically when we assign a value to the variable." 147 | ] 148 | }, 149 | { 150 | "cell_type": "markdown", 151 | "metadata": {}, 152 | "source": [ 153 | "##### Creating a variable and assigning a value\n", 154 | "\n" 155 | ] 156 | }, 157 | { 158 | "cell_type": "markdown", 159 | "metadata": {}, 160 | "source": [ 161 | "We can assign a value to the variable at that time variable is created. We can use the assignment operator = to assign a value to a variable.\n", 162 | "\n", 163 | "The operand, which is on the left side of the assignment operator, is a variable name. And the operand, which is the right side of the assignment operator, is the variable’s value.\n", 164 | "\n", 165 | "variable_name = variable_value" 166 | ] 167 | }, 168 | { 169 | "cell_type": "code", 170 | "execution_count": 1, 171 | "metadata": {}, 172 | "outputs": [ 173 | { 174 | "name": "stdout", 175 | "output_type": "stream", 176 | "text": [ 177 | "Deepali\n", 178 | "25\n", 179 | "25800.6\n" 180 | ] 181 | } 182 | ], 183 | "source": [ 184 | "name = \"Deepali\" # string assignment\n", 185 | "age = 25 # integer assignment\n", 186 | "salary = 25800.60 # float assignment\n", 187 | "\n", 188 | "print(name) # Deepali\n", 189 | "print(age) # 25\n", 190 | "print(salary) # 25800.6" 191 | ] 192 | }, 193 | { 194 | "cell_type": "markdown", 195 | "metadata": {}, 196 | "source": [ 197 | "In the above example, “Deepali”, 25, 25800.60 are values that are assigned to name, age, and salary respectively." 198 | ] 199 | }, 200 | { 201 | "cell_type": "markdown", 202 | "metadata": {}, 203 | "source": [ 204 | "## Changing the value of a variable" 205 | ] 206 | }, 207 | { 208 | "cell_type": "markdown", 209 | "metadata": {}, 210 | "source": [ 211 | "Many programming languages are statically typed languages where the variable is initially declared with a specific type, and during its lifetime, it must always have that type.\n", 212 | "\n", 213 | "But in Python, variables are dynamically typed and not subject to the data type restriction. A variable may be assigned to a value of one type, and then later, we can also re-assigned a value of a different type. " 214 | ] 215 | }, 216 | { 217 | "cell_type": "code", 218 | "execution_count": 2, 219 | "metadata": {}, 220 | "outputs": [ 221 | { 222 | "name": "stdout", 223 | "output_type": "stream", 224 | "text": [ 225 | "10\n", 226 | "\n", 227 | "55\n", 228 | "Now I'm a string\n", 229 | "\n", 230 | "35.69\n", 231 | "\n" 232 | ] 233 | } 234 | ], 235 | "source": [ 236 | "var = 10\n", 237 | "print(var) # 10\n", 238 | "# print its type\n", 239 | "print(type(var)) # \n", 240 | "\n", 241 | "# assign different integer value to var\n", 242 | "var = 55\n", 243 | "print(var) # 55\n", 244 | "\n", 245 | "# change var to string\n", 246 | "var = \"Now I'm a string\"\n", 247 | "print(var) # Now I'm a string\n", 248 | "# print its type\n", 249 | "print(type(var)) # \n", 250 | "\n", 251 | "# change var to float\n", 252 | "var = 35.69\n", 253 | "print(var) # 35.69\n", 254 | "# print its type\n", 255 | "print(type(var)) # " 256 | ] 257 | }, 258 | { 259 | "cell_type": "markdown", 260 | "metadata": {}, 261 | "source": [ 262 | "## Create Number, String, List variables" 263 | ] 264 | }, 265 | { 266 | "cell_type": "markdown", 267 | "metadata": {}, 268 | "source": [ 269 | "We can create different types of variables as per our requirements." 270 | ] 271 | }, 272 | { 273 | "cell_type": "markdown", 274 | "metadata": {}, 275 | "source": [ 276 | "### Number" 277 | ] 278 | }, 279 | { 280 | "cell_type": "markdown", 281 | "metadata": {}, 282 | "source": [ 283 | "A number is a data type to store numeric values. The object for the number will be created when we assign a value to the variable. In Python3, we can use the following three data types to store numeric values.\n", 284 | "\n", 285 | "1. Int\n", 286 | "2. float\n", 287 | "3. complex" 288 | ] 289 | }, 290 | { 291 | "cell_type": "markdown", 292 | "metadata": {}, 293 | "source": [ 294 | "### Integer variable" 295 | ] 296 | }, 297 | { 298 | "cell_type": "markdown", 299 | "metadata": {}, 300 | "source": [ 301 | "The int is a data type that returns integer type values (signed integers); they are also called ints or integers. The integer value can be positive or negative without a decimal point." 302 | ] 303 | }, 304 | { 305 | "cell_type": "code", 306 | "execution_count": 3, 307 | "metadata": {}, 308 | "outputs": [ 309 | { 310 | "name": "stdout", 311 | "output_type": "stream", 312 | "text": [ 313 | "24\n", 314 | "\n" 315 | ] 316 | } 317 | ], 318 | "source": [ 319 | "# create integer variable\n", 320 | "age = 24\n", 321 | "print(age) # 24\n", 322 | "print(type(age)) # " 323 | ] 324 | }, 325 | { 326 | "cell_type": "markdown", 327 | "metadata": {}, 328 | "source": [ 329 | "Note: We used the built-in Python method type() to check the variable type." 330 | ] 331 | }, 332 | { 333 | "cell_type": "markdown", 334 | "metadata": {}, 335 | "source": [ 336 | "### Float variable" 337 | ] 338 | }, 339 | { 340 | "cell_type": "markdown", 341 | "metadata": {}, 342 | "source": [ 343 | "Floats are the values with the decimal point dividing the integer and the fractional parts of the number. Use float data type to store decimal values." 344 | ] 345 | }, 346 | { 347 | "cell_type": "code", 348 | "execution_count": 4, 349 | "metadata": {}, 350 | "outputs": [ 351 | { 352 | "name": "stdout", 353 | "output_type": "stream", 354 | "text": [ 355 | "10800.55\n", 356 | "\n" 357 | ] 358 | } 359 | ], 360 | "source": [ 361 | "# create float variable\n", 362 | "salary = 10800.55\n", 363 | "print(salary) # 10800.55\n", 364 | "print(type(salary)) # " 365 | ] 366 | }, 367 | { 368 | "cell_type": "markdown", 369 | "metadata": {}, 370 | "source": [ 371 | "\n", 372 | "In the above example, the variable salary assigned to value 10800.55, which is a float value." 373 | ] 374 | }, 375 | { 376 | "cell_type": "markdown", 377 | "metadata": {}, 378 | "source": [ 379 | "### Complex type" 380 | ] 381 | }, 382 | { 383 | "cell_type": "markdown", 384 | "metadata": {}, 385 | "source": [ 386 | "The complex is the numbers that come with the real and imaginary part. A complex number is in the form of a+bj, where a and b contain integers or floating-point values." 387 | ] 388 | }, 389 | { 390 | "cell_type": "code", 391 | "execution_count": 5, 392 | "metadata": {}, 393 | "outputs": [ 394 | { 395 | "name": "stdout", 396 | "output_type": "stream", 397 | "text": [ 398 | "(9+5j)\n", 399 | "\n" 400 | ] 401 | } 402 | ], 403 | "source": [ 404 | "a = 9 + 5j\n", 405 | "print(a) # (9+5j)\n", 406 | "print(type(a)) # " 407 | ] 408 | }, 409 | { 410 | "cell_type": "markdown", 411 | "metadata": {}, 412 | "source": [ 413 | "### String variable" 414 | ] 415 | }, 416 | { 417 | "cell_type": "markdown", 418 | "metadata": {}, 419 | "source": [ 420 | "In Python, a string is a set of characters represented in quotation marks. Python allows us to define a string in either pair of single or double quotation marks. For example, to store a person’s name we can use a string type." 421 | ] 422 | }, 423 | { 424 | "cell_type": "markdown", 425 | "metadata": {}, 426 | "source": [ 427 | "To retrieve a piece of string from a given string, we can use to slice operator [] or [:]. Slicing provides us the subset of a string with an index starting from index 0 to index end-1.\n", 428 | "\n", 429 | "To concatenate the string, we can use the addition(+) operator." 430 | ] 431 | }, 432 | { 433 | "cell_type": "code", 434 | "execution_count": 6, 435 | "metadata": {}, 436 | "outputs": [ 437 | { 438 | "name": "stdout", 439 | "output_type": "stream", 440 | "text": [ 441 | "DataScience\n", 442 | "D\n", 443 | "taS\n", 444 | "11\n", 445 | "DataScienceTEST\n" 446 | ] 447 | } 448 | ], 449 | "source": [ 450 | "# create a variable of type string\n", 451 | "str = 'DataScience'\n", 452 | "# prints complete string\n", 453 | "print(str) # Data Science\n", 454 | "\n", 455 | "# prints first character of the string\n", 456 | "print(str[0]) # D\n", 457 | "\n", 458 | "# prints characters starting from 2nd to 5th\n", 459 | "print(str[2:5]) # taS\n", 460 | "\n", 461 | "# length of string\n", 462 | "print(len(str)) # 12\n", 463 | "\n", 464 | "# concatenate string\n", 465 | "print(str + \"TEST\") # Data ScienceTEST" 466 | ] 467 | }, 468 | { 469 | "cell_type": "markdown", 470 | "metadata": {}, 471 | "source": [ 472 | "## Print" 473 | ] 474 | }, 475 | { 476 | "cell_type": "code", 477 | "execution_count": 5, 478 | "metadata": {}, 479 | "outputs": [ 480 | { 481 | "name": "stdout", 482 | "output_type": "stream", 483 | "text": [ 484 | "hi how are you\n" 485 | ] 486 | } 487 | ], 488 | "source": [ 489 | "print(\"hi how are you\")" 490 | ] 491 | }, 492 | { 493 | "cell_type": "code", 494 | "execution_count": 6, 495 | "metadata": {}, 496 | "outputs": [ 497 | { 498 | "name": "stdout", 499 | "output_type": "stream", 500 | "text": [ 501 | "HiHello\n" 502 | ] 503 | } 504 | ], 505 | "source": [ 506 | "print(\"Hi\" + \"Hello\")" 507 | ] 508 | }, 509 | { 510 | "cell_type": "code", 511 | "execution_count": 7, 512 | "metadata": {}, 513 | "outputs": [ 514 | { 515 | "name": "stdout", 516 | "output_type": "stream", 517 | "text": [ 518 | "Hi Hello\n" 519 | ] 520 | } 521 | ], 522 | "source": [ 523 | "print(\"Hi\"+ \" \"+ \"Hello\")" 524 | ] 525 | }, 526 | { 527 | "cell_type": "code", 528 | "execution_count": 8, 529 | "metadata": {}, 530 | "outputs": [ 531 | { 532 | "name": "stdout", 533 | "output_type": "stream", 534 | "text": [ 535 | "HyderabadHyderabadHyderabad\n" 536 | ] 537 | } 538 | ], 539 | "source": [ 540 | "print(\"Hyderabad\" * 3) # its prints string multiple times" 541 | ] 542 | }, 543 | { 544 | "cell_type": "code", 545 | "execution_count": 9, 546 | "metadata": {}, 547 | "outputs": [ 548 | { 549 | "name": "stdout", 550 | "output_type": "stream", 551 | "text": [ 552 | "I multipy 6 Is the result\n" 553 | ] 554 | } 555 | ], 556 | "source": [ 557 | "print(\"I multipy\", 2 * 3 , \"Is the result\") # print multiply with numbers" 558 | ] 559 | }, 560 | { 561 | "cell_type": "markdown", 562 | "metadata": {}, 563 | "source": [ 564 | "#### multi lines strings" 565 | ] 566 | }, 567 | { 568 | "cell_type": "code", 569 | "execution_count": 10, 570 | "metadata": {}, 571 | "outputs": [ 572 | { 573 | "name": "stdout", 574 | "output_type": "stream", 575 | "text": [ 576 | "To get the list of all keywords of Python programmatically, you can use kwlist of keyword library. \n", 577 | "Following is the quick code snippet to get the list of all keywords. \n", 578 | "kwlist returns sequence containing all the keywords defined for the interpreter.\n" 579 | ] 580 | } 581 | ], 582 | "source": [ 583 | "print('''To get the list of all keywords of Python programmatically, you can use kwlist of keyword library. \n", 584 | "Following is the quick code snippet to get the list of all keywords. \n", 585 | "kwlist returns sequence containing all the keywords defined for the interpreter.''')" 586 | ] 587 | }, 588 | { 589 | "cell_type": "markdown", 590 | "metadata": {}, 591 | "source": [ 592 | "### print with space , \\n , \\t" 593 | ] 594 | }, 595 | { 596 | "cell_type": "code", 597 | "execution_count": 11, 598 | "metadata": {}, 599 | "outputs": [ 600 | { 601 | "name": "stdout", 602 | "output_type": "stream", 603 | "text": [ 604 | " Hi How are you?\n" 605 | ] 606 | } 607 | ], 608 | "source": [ 609 | "print(\" Hi How are you?\")" 610 | ] 611 | }, 612 | { 613 | "cell_type": "code", 614 | "execution_count": 12, 615 | "metadata": {}, 616 | "outputs": [ 617 | { 618 | "name": "stdout", 619 | "output_type": "stream", 620 | "text": [ 621 | " hi \n", 622 | "How are you\n" 623 | ] 624 | } 625 | ], 626 | "source": [ 627 | "print( \" hi \\nHow are you\")" 628 | ] 629 | }, 630 | { 631 | "cell_type": "code", 632 | "execution_count": 14, 633 | "metadata": {}, 634 | "outputs": [ 635 | { 636 | "name": "stdout", 637 | "output_type": "stream", 638 | "text": [ 639 | "hi\thiiiiiiiiiii\n" 640 | ] 641 | } 642 | ], 643 | "source": [ 644 | "print(\"hi\\thiiiiiiiiiii\")" 645 | ] 646 | }, 647 | { 648 | "cell_type": "code", 649 | "execution_count": 15, 650 | "metadata": {}, 651 | "outputs": [ 652 | { 653 | "ename": "SyntaxError", 654 | "evalue": "invalid syntax (, line 1)", 655 | "output_type": "error", 656 | "traceback": [ 657 | "\u001b[1;36m File \u001b[1;32m\"\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m print('I don't know')\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n" 658 | ] 659 | } 660 | ], 661 | "source": [ 662 | "print('I don't know')" 663 | ] 664 | }, 665 | { 666 | "cell_type": "code", 667 | "execution_count": 16, 668 | "metadata": {}, 669 | "outputs": [ 670 | { 671 | "name": "stdout", 672 | "output_type": "stream", 673 | "text": [ 674 | "I don't know\n" 675 | ] 676 | } 677 | ], 678 | "source": [ 679 | "print('I don\\'t know')" 680 | ] 681 | }, 682 | { 683 | "cell_type": "code", 684 | "execution_count": 18, 685 | "metadata": {}, 686 | "outputs": [ 687 | { 688 | "name": "stdout", 689 | "output_type": "stream", 690 | "text": [ 691 | "\"Hi\", He Said\n" 692 | ] 693 | } 694 | ], 695 | "source": [ 696 | "print(\"\\\"Hi\\\", He Said\") " 697 | ] 698 | }, 699 | { 700 | "cell_type": "code", 701 | "execution_count": 19, 702 | "metadata": {}, 703 | "outputs": [], 704 | "source": [ 705 | "pi = 3.141592653" 706 | ] 707 | }, 708 | { 709 | "cell_type": "code", 710 | "execution_count": 20, 711 | "metadata": {}, 712 | "outputs": [ 713 | { 714 | "name": "stdout", 715 | "output_type": "stream", 716 | "text": [ 717 | "I am pi 3\n" 718 | ] 719 | } 720 | ], 721 | "source": [ 722 | "print(\"I am pi %d\"%(pi)) # %d is place holder for Integers" 723 | ] 724 | }, 725 | { 726 | "cell_type": "code", 727 | "execution_count": 21, 728 | "metadata": {}, 729 | "outputs": [ 730 | { 731 | "name": "stdout", 732 | "output_type": "stream", 733 | "text": [ 734 | "I am pi 3.141593\n" 735 | ] 736 | } 737 | ], 738 | "source": [ 739 | "print(\"I am pi %f\"%(pi)) # %f is place holder for Integers" 740 | ] 741 | }, 742 | { 743 | "cell_type": "code", 744 | "execution_count": 22, 745 | "metadata": {}, 746 | "outputs": [ 747 | { 748 | "name": "stdout", 749 | "output_type": "stream", 750 | "text": [ 751 | "I am pi 3.142\n" 752 | ] 753 | } 754 | ], 755 | "source": [ 756 | "print(\"I am pi %.3f\"%(pi)) # %f is place holder for Integers" 757 | ] 758 | }, 759 | { 760 | "cell_type": "code", 761 | "execution_count": 23, 762 | "metadata": {}, 763 | "outputs": [], 764 | "source": [ 765 | "x = 25\n", 766 | "y = 2\n", 767 | "tempScale = 'Celsius'" 768 | ] 769 | }, 770 | { 771 | "cell_type": "code", 772 | "execution_count": 24, 773 | "metadata": {}, 774 | "outputs": [ 775 | { 776 | "name": "stdout", 777 | "output_type": "stream", 778 | "text": [ 779 | "The temperature is 12.50 Celsius\n" 780 | ] 781 | } 782 | ], 783 | "source": [ 784 | "print(\"The temperature is %.2f %s\"%(x/y, tempScale))" 785 | ] 786 | }, 787 | { 788 | "cell_type": "code", 789 | "execution_count": 25, 790 | "metadata": {}, 791 | "outputs": [ 792 | { 793 | "name": "stdout", 794 | "output_type": "stream", 795 | "text": [ 796 | "I am FIVE 5, I am SIX 6\n" 797 | ] 798 | } 799 | ], 800 | "source": [ 801 | "a = 5\n", 802 | "b = 6\n", 803 | "print(\"I am FIVE {}, I am SIX {}\".format(a,b))" 804 | ] 805 | }, 806 | { 807 | "cell_type": "code", 808 | "execution_count": 26, 809 | "metadata": {}, 810 | "outputs": [ 811 | { 812 | "name": "stdout", 813 | "output_type": "stream", 814 | "text": [ 815 | "I am pi 3.141592653\n" 816 | ] 817 | } 818 | ], 819 | "source": [ 820 | "print(\"I am pi {}\".format(pi))\n" 821 | ] 822 | }, 823 | { 824 | "cell_type": "code", 825 | "execution_count": 27, 826 | "metadata": {}, 827 | "outputs": [ 828 | { 829 | "name": "stdout", 830 | "output_type": "stream", 831 | "text": [ 832 | "I am pi 3.142\n" 833 | ] 834 | } 835 | ], 836 | "source": [ 837 | "print(\"I am pi {:.3f}\".format(pi))" 838 | ] 839 | }, 840 | { 841 | "cell_type": "markdown", 842 | "metadata": {}, 843 | "source": [ 844 | "If we want to represent a group of elements (or value) as a single entity, we should go for the list variable type. For example, we can use them to store student names. In the list, the insertion order of elements is preserved. That means, in which order elements are inserted in the list, the order will be intact.\n", 845 | "\n", 846 | "The list can be accessed in two ways, either positive or negative index. The list has the following characteristics:\n", 847 | "\n", 848 | "1. In the list insertion order of elements is preserved.\n", 849 | "2. Heterogeneous (all types of data types int, float, string) elements are allowed.\n", 850 | "3. Duplicates elements are permitted.\n", 851 | "4. The list is mutable(can change).\n", 852 | "5. Growable in nature means based on our requirement, we can increase or decrease the list’s size.\n", 853 | "6. List elements should be enclosed within square brackets []." 854 | ] 855 | }, 856 | { 857 | "cell_type": "markdown", 858 | "metadata": {}, 859 | "source": [ 860 | "### Variable’s case-sensitive" 861 | ] 862 | }, 863 | { 864 | "cell_type": "markdown", 865 | "metadata": {}, 866 | "source": [ 867 | "Python is a case-sensitive language. If we define a variable with names a = 100 and A =200 then, Python differentiates between a and A. These variables are treated as two different variables (or objects)." 868 | ] 869 | }, 870 | { 871 | "cell_type": "code", 872 | "execution_count": 8, 873 | "metadata": {}, 874 | "outputs": [ 875 | { 876 | "name": "stdout", 877 | "output_type": "stream", 878 | "text": [ 879 | "100\n", 880 | "200\n", 881 | "300\n" 882 | ] 883 | } 884 | ], 885 | "source": [ 886 | "a = 100\n", 887 | "A = 200\n", 888 | "\n", 889 | "# value of a\n", 890 | "print(a) # 100\n", 891 | "# Value of A\n", 892 | "print(A) # 200\n", 893 | "\n", 894 | "a = a + A\n", 895 | "print(a) # 300" 896 | ] 897 | }, 898 | { 899 | "cell_type": "markdown", 900 | "metadata": {}, 901 | "source": [ 902 | "### Constant" 903 | ] 904 | }, 905 | { 906 | "cell_type": "markdown", 907 | "metadata": {}, 908 | "source": [ 909 | "Constant is a variable or value that does not change, which means it remains the same and cannot be modified. But in the case of Python, the constant concept is not applicable. By convention, we can use only uppercase characters to define the constant variable if we don’t want to change it." 910 | ] 911 | }, 912 | { 913 | "cell_type": "code", 914 | "execution_count": 9, 915 | "metadata": {}, 916 | "outputs": [], 917 | "source": [ 918 | "MIN_VALUE = 500\n", 919 | "# It is just convention, but we can change the value of MAX_VALUE variable." 920 | ] 921 | }, 922 | { 923 | "cell_type": "markdown", 924 | "metadata": {}, 925 | "source": [ 926 | "### Rules and naming convention for variables and constants" 927 | ] 928 | }, 929 | { 930 | "cell_type": "markdown", 931 | "metadata": {}, 932 | "source": [ 933 | " A name in a Python program is called an identifier. An identifier can be a variable name, class name, function name, and module name.\n", 934 | "\n", 935 | "There are some rules to define variables in Python.\n", 936 | "\n", 937 | "In Python, there are some conventions and rules to define variables and constants that should follow.\n", 938 | "\n", 939 | "* Rule 1: The name of the variable and constant should have a combination of letters, digits, and underscore symbols.\n", 940 | "\n", 941 | "Alphabet/letters i.e., lowercase (a to z) or uppercase (A to Z)\n", 942 | "Digits(0 to 9)\n", 943 | "Underscore symbol (_)\n", 944 | "\n", 945 | "For Example :\n", 946 | "* total_addition\n", 947 | "* TOTAL_ADDITION\n", 948 | "* totalAddition\n", 949 | "* Totaladdition" 950 | ] 951 | }, 952 | { 953 | "cell_type": "markdown", 954 | "metadata": {}, 955 | "source": [ 956 | " * Rule 2: The variable name and constant name should make sense.\n", 957 | "\n", 958 | "Note: we should always create a meaningful variable name so it will be easy to understand. That is, it should be meaningful.\n", 959 | "\n", 960 | "For Example:\n", 961 | "x = \"Deepali\" \n", 962 | "student_name = \"Deepali\"\n", 963 | "\n", 964 | "It above example variable x does not make more sense, but student_name is a meaningful variable.\n" 965 | ] 966 | }, 967 | { 968 | "cell_type": "markdown", 969 | "metadata": {}, 970 | "source": [ 971 | "* Rule 3: Don’t’ use special symbols in a variable name\n", 972 | "\n", 973 | "For declaring variable and constant, we cannot use special symbols like $, #, @, %, !~, etc. If we try to declare names with a special symbol, Python generates an error\n", 974 | "\n", 975 | "Example\n", 976 | "* ca$h = 1000\n" 977 | ] 978 | }, 979 | { 980 | "cell_type": "markdown", 981 | "metadata": {}, 982 | "source": [ 983 | "* Rule 4: Variable and constant should not start with digit letters.\n", 984 | "\n", 985 | "You will receive an error if you start a variable name with a digit. Let’s verify this using a simple example.\n", 986 | "\n", 987 | "* 1studnet = \"Deepali\"\n", 988 | "* print(1studnet)\n", 989 | "* Here Python will generate a syntax error at 1studnet. instead of this, you can declare a variable like studnet_1 = \"Deepali\"" 990 | ] 991 | }, 992 | { 993 | "cell_type": "markdown", 994 | "metadata": {}, 995 | "source": [ 996 | "* Rule 5: Identifiers are case sensitive.\n", 997 | "\n" 998 | ] 999 | }, 1000 | { 1001 | "cell_type": "code", 1002 | "execution_count": 10, 1003 | "metadata": {}, 1004 | "outputs": [ 1005 | { 1006 | "name": "stdout", 1007 | "output_type": "stream", 1008 | "text": [ 1009 | "120\n", 1010 | "130\n", 1011 | "150\n" 1012 | ] 1013 | } 1014 | ], 1015 | "source": [ 1016 | "total = 120\n", 1017 | "Total = 130\n", 1018 | "TOTAL = 150\n", 1019 | "print(total)\n", 1020 | "print(Total)\n", 1021 | "print(TOTAL)\n" 1022 | ] 1023 | }, 1024 | { 1025 | "cell_type": "markdown", 1026 | "metadata": {}, 1027 | "source": [ 1028 | "Here, Python makes a difference between these variables that is uppercase and lowercase, so that it will create three different variables total, Total, TOTAL." 1029 | ] 1030 | }, 1031 | { 1032 | "cell_type": "markdown", 1033 | "metadata": {}, 1034 | "source": [ 1035 | "* Rule 6: To declare constant should use capital letters.\n", 1036 | "\n" 1037 | ] 1038 | }, 1039 | { 1040 | "cell_type": "code", 1041 | "execution_count": 11, 1042 | "metadata": {}, 1043 | "outputs": [], 1044 | "source": [ 1045 | "MIN_VALUE = 100\n", 1046 | "MAX_VALUE = 1000" 1047 | ] 1048 | }, 1049 | { 1050 | "cell_type": "markdown", 1051 | "metadata": {}, 1052 | "source": [ 1053 | " Use an underscore symbol for separating the words in a variable name\n", 1054 | "\n", 1055 | "If we want to declare variable and constant names having two words, use an underscore symbol for separating the words." 1056 | ] 1057 | }, 1058 | { 1059 | "cell_type": "code", 1060 | "execution_count": 12, 1061 | "metadata": {}, 1062 | "outputs": [], 1063 | "source": [ 1064 | "current_temperature = 24" 1065 | ] 1066 | }, 1067 | { 1068 | "cell_type": "markdown", 1069 | "metadata": {}, 1070 | "source": [ 1071 | "### Assigning multiple values to multiple variables\n" 1072 | ] 1073 | }, 1074 | { 1075 | "cell_type": "code", 1076 | "execution_count": 1, 1077 | "metadata": {}, 1078 | "outputs": [ 1079 | { 1080 | "name": "stdout", 1081 | "output_type": "stream", 1082 | "text": [ 1083 | "10 70 Deepali\n" 1084 | ] 1085 | } 1086 | ], 1087 | "source": [ 1088 | "roll_no, marks, name = 10, 70, \"Deepali\"\n", 1089 | "print(roll_no, marks, name) # 10 20 Deepali" 1090 | ] 1091 | }, 1092 | { 1093 | "cell_type": "markdown", 1094 | "metadata": {}, 1095 | "source": [ 1096 | "In the above example, two integer values 10 and 70 are assigned to variables roll_no and marks, respectively, and string literal, “Deepali,” is assigned to the variable name." 1097 | ] 1098 | }, 1099 | { 1100 | "cell_type": "markdown", 1101 | "metadata": {}, 1102 | "source": [ 1103 | "### Quick Summary to keep in mind:" 1104 | ] 1105 | }, 1106 | { 1107 | "cell_type": "markdown", 1108 | "metadata": {}, 1109 | "source": [ 1110 | "Checklist while giving variable names\n", 1111 | " - Allowed values -> alphabets, numbers and underscore (_).\n", 1112 | " - A variable name should start with alphabet or underscore. It can not start with a number.\n", 1113 | " - Variable names are case-sensitive." 1114 | ] 1115 | }, 1116 | { 1117 | "cell_type": "code", 1118 | "execution_count": null, 1119 | "metadata": {}, 1120 | "outputs": [], 1121 | "source": [] 1122 | } 1123 | ], 1124 | "metadata": { 1125 | "kernelspec": { 1126 | "display_name": "Python 3", 1127 | "language": "python", 1128 | "name": "python3" 1129 | }, 1130 | "language_info": { 1131 | "codemirror_mode": { 1132 | "name": "ipython", 1133 | "version": 3 1134 | }, 1135 | "file_extension": ".py", 1136 | "mimetype": "text/x-python", 1137 | "name": "python", 1138 | "nbconvert_exporter": "python", 1139 | "pygments_lexer": "ipython3", 1140 | "version": "3.8.3" 1141 | } 1142 | }, 1143 | "nbformat": 4, 1144 | "nbformat_minor": 4 1145 | } 1146 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Hello All, 2 | First of all thank you for visiting my page. I am Data Science student at Innomatics Research Lab in Hyderabad. 3 | 4 | As a non programmer , i have created my own notes from basic python to EDA , which any fresher can understand easily. 5 | 6 | I hope it will be helpful for all too. 7 | 8 | For any query or suggestions fell free to connect on my LinkedIn. https://www.linkedin.com/in/shinde-deepali-r-tipirneni-25263914b 9 | 10 | gmail : deepalishinde7890@gmail.com 11 | --------------------------------------------------------------------------------