{"id":40611,"date":"2025-07-17T19:37:55","date_gmt":"2025-07-17T16:37:55","guid":{"rendered":"https:\/\/goit.global\/?post_type=articles&p=40611"},"modified":"2026-04-30T14:39:56","modified_gmt":"2026-04-30T11:39:56","slug":"slovnyky-v-python-shcho-potribno-znaty","status":"publish","type":"articles","link":"https:\/\/goit.global\/ua\/articles\/slovnyky-v-python-shcho-potribno-znaty\/","title":{"rendered":"\u0421\u043b\u043e\u0432\u043d\u0438\u043a\u0438 \u0432 Python: \u0449\u043e \u043f\u043e\u0442\u0440\u0456\u0431\u043d\u043e \u0437\u043d\u0430\u0442\u0438 \u0456 \u044f\u043a \u043a\u043e\u0440\u0438\u0441\u0442\u0443\u0432\u0430\u0442\u0438\u0441\u044c"},"content":{"rendered":"

І ось тут на сцену виходять словники в Python – інструмент, який буквально змінить твій підхід до коду і даних. Готовий дізнатись, чому словники Пайтон<\/a> стануть твоєю секретною зброєю в будь-якій IT-сфері? Тоді ця стаття написана спеціально для тебе!<\/p>\n

<\/source><\/source><\/source><\/source><\/picture><\/a>\n<\/p>\n

Що таке словник у Python простими словами<\/h2>\n

\nУяви: ти більше не шукаєш інформацію за списком, перебираючи елементи один за одним. Ти миттєво отримуєш доступ до потрібних даних, просто назвавши їх! Саме так працює словник Пайтон (або, як його називають профі, dict у Python).<\/p>\n

Це не просто спосіб зберігати інформацію – це спосіб миттєво витягати її, використовуючи унікальні ключі словника Python. Твій ключ значення Пайтон – це миттєвий зв’язок між питанням і відповіддю, між запитом і потрібною інформацією. Це як персональний помічник, який знає, де лежить кожна дрібниця, і подає її на перший запит.<\/p>\n

Зрозумій, словник програмування – це не просто теорія з підручника. Це основа для створення баз даних, роботи з API<\/a>, обробки конфігурацій та багато чого іншого. Він ідеальний, коли тобі потрібно представити складні об’єкти або швидко отримати доступ до даних за їх ім’ям, а не за порядковим номером.<\/p>\n

У цьому і полягає кардинальна відмінність від списків, де порядок важливий, але пошук за значенням не такий ефективний. І якщо ти хочеш по-справжньому розуміти, які бувають словники та коли їх використовувати, щоб твій код був швидким і ефективним, тобі точно потрібно опанувати цю тему. Адже в IT швидкість і точність – це все!<\/p>\n

Наприклад, на відміну від списків, словники (з Python 3.7 і вище<\/a>) зберігають порядок додавання елементів, але головна їх перевага – це все ж таки швидкий доступ за ключем, а не за індексом. А ще вони відрізняються від множин (sets), які просто зберігають унікальні елементи без будь-якого зв’язку «ключ-значення». Таким чином, якщо твоє завдання – швидко знаходити інформацію за унікальним ідентифікатором, то словник – це точно те, що тобі потрібно!\n<\/p>\n

Як створити свій перший словник у Python<\/h2>\n

\nДумаєш, що опанування нових інструментів – це складно? Відкинь ці думки! Створення словника Python<\/a> – це досить просто. Є кілька способів, і кожен з них зручний для своєї ситуації, адже в реальних проєктах дані надходять у різних форматах.<\/p>\n

Найпоширеніший спосіб, який ти будеш використовувати найчастіше – це створення словника за допомогою фігурних дужок {}<\/strong> і одразу ж заповнення їх ключами та значеннями. Почнемо з порожнього словника – це як чистий аркуш, готовий до наповнення: my_empty_dict = {}<\/strong>. І коли ти його виведеш, побачиш просто {}<\/strong>:<\/p>\n

my_empty_dict = {}<\/em><\/p>\n

print(my_empty_dict)<\/em><\/p>\n

А тепер створимо словник з твоїм «профілем» – реальні дані, які ти можеш одразу використовувати! Тут “name”, “age”, “city”, “is_student” – це ключі, а “Олександр”, 30, “Київ”, False – відповідні їм значення. Подивись, як це виглядає в коді:<\/p>\n

user_profile = {<\/em><\/p>\n

    “name”: “Олександр”,<\/em><\/p>\n

    “age”: 30,<\/em><\/p>\n

    “city”: “Київ”,<\/em><\/p>\n

    “is_student”: False  # Поки що ні? У GoIT є рішення!<\/em><\/p>\n

}<\/em><\/p>\n

print(user_profile)<\/em><\/p>\n

Вивід<\/strong>:<\/p>\n

{}<\/em><\/p>\n

{‘name’: ‘Олександр’, ‘age’: 30, ‘city’: ‘Київ’, ‘is_student’: False}<\/em><\/p>\n

Хочеш ще один спосіб, який виручить при роботі з конкретними, заздалегідь відомими даними? Використовуй функцію dict()<\/strong> з іменованими аргументами, щоб створити словник у Пайтоні<\/a>. Уяви, що це дані про товар у твоєму інтернет-магазині. Зручно, коли назва поля одразу стає ключем!<\/p>\n

another_dict = dict(brand=”Ford”, model=”Mustang”, year=1964)<\/em><\/p>\n

print(another_dict)<\/em><\/p>\n

Вивід<\/strong>:<\/p>\n

{‘brand’: ‘Ford’, ‘model’: ‘Mustang’, ‘year’: 1964}<\/em><\/p>\n

А що, якщо у тебе вже є дані у вигляді списків, і їх потрібно перетворити на словник? Не проблема! Ти можеш створити словник зі списку Python, використовуючи функцію zip()<\/strong>, яка «склеює» елементи з двох списків у пари. Потім передай цей результат функції dict()<\/strong>, і вона миттєво сконвертує його в словник. Припустимо, у тебе є список назв міст і їх населення:<\/p>\n

cities = [“Київ”, “Львів”, “Одеса”]<\/em><\/p>\n

population = [2952000, 720000, 1015000]<\/em><\/p>\n

city_population = dict(zip(cities, population))  # zip() “склеїть” їх у пари, які dict() перетворить на словник<\/em><\/p>\n

print(city_population)<\/em><\/p>\n

Вивід<\/strong>:<\/p>\n

{‘Київ’: 2952000, ‘Львів’: 720000, ‘Одеса’: 1015000}<\/em><\/p>\n

Бачиш, як просто? І це лише початок!\n<\/p>\n

Генератори словників Пайтон<\/h3>\n

\nХочеш писати код, який виглядає круто, працює швидко і дивує своєю лаконічністю? Тоді тобі точно потрібно опанувати генератори словників. Це не просто синтаксичний цукор – це потужний інструмент для швидкого й ефективного створення словника Python<\/a> на основі вже наявних даних або певних логічних правил. Це вже один із прикладів просунутих операцій зі словниками Python, який заощадить тобі десятки рядків коду в майбутньому.<\/p>\n

Уяви, що тобі потрібно створити словник, де ключ – число, а значення – його квадрат. За допомогою генератора це робиться за допомогою squares_dict<\/strong>:<\/p>\n

squares_dict = {num: num**2 for num in range(6)}  # Створюємо словник для чисел від 0 до 5<\/em><\/p>\n

print(squares_dict)<\/em><\/p>\n

Або, якщо у тебе є список кортежів (пар), і ти хочеш перетворити його на словник, ти можеш використати grades_dict:<\/p>\n

student_grades = [(‘Анна’, ‘A’), (‘Богдан’, ‘B’), (‘Віктор’, ‘C’)]<\/em><\/p>\n

grades_dict = {name: grade for name, grade in student_grades}<\/em><\/p>\n

print(grades_dict)<\/em><\/p>\n

Вивід<\/strong>:<\/p>\n

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}<\/em><\/p>\n

{‘Анна’: ‘A’, ‘Богдан’: ‘B’, ‘Віктор’: ‘C’}<\/em><\/p>\n

Опанувавши генератори, ти одразу ж піднімеш навички кодування на зовсім інший рівень!<\/p>\n

<\/source><\/source><\/source><\/source><\/picture><\/a>\n<\/p>\n

Як працювати зі словниками Python<\/h2>\n

\nТвій словник готовий, наповнений даними. Тепер починається найцікавіше: як витягувати, додавати, змінювати й видаляти інформацію, загалом – як працювати зі словниками Пайтон. Ці навички є основою для будь-якого проєкту, хай то вебзастосунок, аналіз даних чи автоматизація.\n<\/p>\n

Доступ до даних: як дістати потрібне значення миттєво<\/h3>\n

\nНайчастіша операція – це, звичайно, отримання значення за ключем. Для звернення до словника Python просто використовуй квадратні дужки []<\/strong> і вкажи потрібний ключ. Наприклад, щоб отримати ім’я користувача, ти напишеш print(user_profile[“name”])<\/strong>, і побачиш “Олександр”.<\/p>\n

Увага, питання: що станеться, якщо ти спробуєш отримати значення за ключем, якого немає в словнику? Пайтон видасть KeyError<\/strong>, і твоя програма зупиниться. А в реальних проєктах це рівносильно катастрофі! Щоб цього уникнути, завжди використовуй розумний метод get Python<\/a>. Він дозволяє тобі вказати «запасний» варіант (значення за замовчуванням), яке повернеться, якщо потрібного ключа не знайшлося. Це рятує тебе від помилок і робить твій код надійним. Розглянемо на прикладі:<\/p>\n

print(user_profile[“name”])  # Отримуємо ім’я користувача<\/em><\/p>\n

print(user_profile.get(“city”))  # Отримуємо місто, якщо воно є<\/em><\/p>\n

print(user_profile.get(“country”, “Не вказано”))  # Якщо “country” немає, побачимо “Не вказано”, а не помилку!<\/em><\/p>\n

user_profile.get(“city”)<\/strong> поверне “Київ”, але user_profile.get(“country”, “Не вказано”)<\/strong> поверне “Не вказано”, тому що ключа “country” немає, і при цьому жодної помилки не буде.<\/p>\n

Вивід<\/strong>:<\/p>\n

Олександр  <\/em><\/p>\n

Київ  <\/em><\/p>\n

Не вказано<\/em><\/p>\n

Бачиш, як метод get Python робить твій код стійким? Це маст-хев для кожного, хто не хоче, щоб його програми «падали»!\n<\/p>\n

Як додавати дані до словника Пайтон<\/h3>\n

\nТвої дані не статичні, вони постійно змінюються. І Пайтон-словник ідеально підходить для цього! Додати значення до словника Python або змінити чинне можна неймовірно легко – просто присвой нове значення за ключем. Якщо такого ключа ще немає – він буде автоматично доданий, а якщо є – його значення оновиться. Наприклад, щоб додати email і оновити вік, варто написати:<\/p>\n

user_profile[“email”] = “alex@goit.global”  # Додали новий контактний email<\/em><\/p>\n

user_profile[“age”] = 32  # Збільшили вік<\/em><\/p>\n

print(user_profile)<\/em><\/p>\n

Вивід<\/strong>:<\/p>\n

{‘name’: ‘Олександр’, ‘age’: 32, ‘city’: ‘Київ’, ‘is_student’: False, ’email’: ‘alex@goit.global’}<\/em><\/p>\n

Як видалити значення зі словника Пайтон<\/h3>\n

\nІноді інформація застаріває, або тобі просто потрібно видалити якийсь елемент зі словника. Python пропонує для цього прості та ефективні способи.<\/p>\n

Використовуй оператор del<\/strong>, якщо ти хочеш просто видалити елемент за ключем, і тобі не потрібне його значення. Наприклад, del user_profile<\/strong> видалить цей ключ і його значення зі словника.<\/p>\n

del user_profile[“is_student”]  # Видалили статус студента<\/em><\/p>\n

print(user_profile)<\/em><\/p>\n

Якщо ж ти хочеш не лише видалити елемент, а й отримати його значення (можливо, щоб використати його десь ще), використовуй метод pop()<\/strong>. Це як витягнути елемент зі словника та одразу ж його використати.<\/p>\n

user_email = user_profile.pop(“email”)  # Видаляємо email і зберігаємо його в змінній user_email<\/em><\/p>\n

print(user_profile)<\/em><\/p>\n

print(f”Видалений email: {user_email}”)<\/em><\/p>\n

Вивід<\/strong>:<\/p>\n

{‘name’: ‘Олександр’, ‘age’: 32, ‘city’: ‘Київ’}<\/em><\/p>\n

Видалений email: alex@goit.global<\/em><\/p>\n

А якщо потрібно повністю очистити словник Python від усіх елементів, зробивши його порожнім, використовуй метод clear()<\/strong>. Просто виклич user_profile.clear()<\/strong>, і твій словник знову буде порожнім: {}<\/strong>.<\/p>\n

user_profile.clear()<\/em><\/p>\n

print(user_profile)<\/em><\/p>\n

Вивід<\/strong>:<\/p>\n

{}<\/em>\n<\/p>\n

Методи словників Python<\/h2>\n

\nМетоди словників Пайтон (або методи dict Python) – це твій набір інструментів, який робить роботу зі словниками в Пайтон<\/a> не просто можливою, а неймовірно ефективною. Це як розширений функціонал, що дозволяє отримати максимум з твоїх даних.<\/p>\n

Три найчастіше використовувані методи для отримання «представлень» вмісту словника – це keys()<\/strong>, values()<\/strong> і items()<\/strong>. Метод keys()<\/strong> повертає об’єкт-представлення всіх ключів Python у словнику, дозволяючи тобі просто побачити, які «мітки» є у твоєму словнику. Метод values()<\/strong> повертає об’єкт-представлення всіх значень у словнику – корисно, коли тобі потрібен тільки сам контент, без прив’язки до ключів. А метод items()<\/strong> повертає об’єкт-представлення всіх пар «ключ-значення» у словнику, представлених у вигляді кортежів, що ідеально, коли тобі потрібна повна інформація про кожен елемент.<\/p>\n

Але досить теорії – розгляньмо ці методи на практиці:<\/p>\n

products = {<\/em><\/p>\n

    “ноутбук”: 1200,<\/em><\/p>\n

    “миша”: 25,<\/em><\/p>\n

    “клавіатура”: 75,<\/em><\/p>\n

    “монітор”: 300<\/em><\/p>\n

}<\/em><\/p>\n

print(f”Усі ключі: {products.keys()}”)<\/em><\/p>\n

print(f”Усі значення: {products.values()}”)<\/em><\/p>\n

print(f”Усі пари ключ-значення: {products.items()}”)<\/em><\/p>\n

Вивід<\/strong>:<\/p>\n

Усі ключі: dict_keys([‘ноутбук’, ‘миша’, ‘клавіатура’, ‘монітор’])<\/em><\/p>\n

Усі значення: dict_values([1200, 25, 75, 300])<\/em><\/p>\n

Усі пари ключ-значення: dict_items([(‘ноутбук’, 1200), (‘миша’, 25), (‘клавіатура’, 75), (‘монітор’, 300)])<\/em><\/p>\n

Ці «представлення» не є повноцінними списками, але вони поводяться як ітеровані об’єкти, що дуже зручно для циклів.<\/p>\n

Метод update()<\/strong> дозволяє тобі додати словник у словник Python або оновити наявні елементи, використовуючи дані з іншого словника або будь-якого ітерованого об’єкта, що містить пари «ключ-значення». Це як злиття двох джерел даних в один актуальний словник. Наприклад, якщо у тебе є базові налаштування user_settings<\/strong> і нові new_preferences<\/strong>, ти можеш об’єднати їх за допомогою user_settings.update<\/strong>.<\/p>\n

user_settings = {“theme”: “dark”, “notifications”: True}<\/em><\/p>\n

new_preferences = {“font_size”: 14, “theme”: “light”, “language”: “ua”}  # Новий словник для оновлення<\/em><\/p>\n

user_settings.update(new_preferences)  # Оновлюємо налаштування користувача<\/em><\/p>\n

print(user_settings)<\/em><\/p>\n

Вивід<\/strong>:<\/p>\n

{‘theme’: ‘light’, ‘notifications’: True, ‘font_size’: 14, ‘language’: ‘ua’}<\/em><\/p>\n

Метод copy()<\/strong> створює поверхневу копію словника. Це надзвичайно важливо, щоб уникнути небажаних змін в оригінальному словнику, коли ти працюєш з його копією. Без copy()<\/strong> будь-які зміни в «копії» зачеплять і оригінал, що може призвести до непередбачуваних багів. Пам’ятай: copied_dict = original_dict.copy()<\/strong> – твій найкращий друг для безпечного дублювання.<\/p>\n

original_config = {‘mode’: ‘test’, ‘level’: 1}<\/em><\/p>\n

modified_config = original_config.copy()  # Створюємо справжню копію<\/em><\/p>\n

modified_config[‘level’] = 5  # Змінюємо лише копію<\/em><\/p>\n

print(f”Оригінал: {original_config}”)<\/em><\/p>\n

print(f”Копія: {modified_config}”)<\/em><\/p>\n

Вивід<\/strong>:<\/p>\n

Оригінал: {‘mode’: ‘test’, ‘level’: 1}<\/em><\/p>\n

Копія: {‘mode’: ‘test’, ‘level’: 5}<\/em><\/p>\n

Метод fromkeys()<\/strong> створює новий словник із заданої послідовності ключів, присвоюючи їм усім одне й те саме значення за замовчуванням. Чудово підходить для ініціалізації словників, наприклад, щоб розпочати підрахунок балів для списку студентів.<\/p>\n

student_names = [‘Іван’, ‘Марія’, ‘Петро’]<\/em><\/p>\n

initial_score = 0<\/em><\/p>\n

student_scores = dict.fromkeys(student_names, initial_score)<\/em><\/p>\n

print(student_scores)<\/em><\/p>\n

Вивід<\/strong>:<\/p>\n

{‘Іван’: 0, ‘Марія’: 0, ‘Петро’: 0}<\/em>\n<\/p>\n

Як перебрати елементи словника Пайтон<\/h3>\n

\nПросто мати дані у словнику недостатньо – тобі часто знадобиться пройтися по всіх елементах, щоб обробити їх, вивести на екран або виконати якісь операції. Це називається ітерацією, і це базова, але дуже важлива частина роботи з dict Python<\/a>. Вона показує, як використовувати функції словників Пайтон у реальних сценаріях.<\/p>\n

Уяви, що в тебе є словник з оцінками студентів class_scores<\/strong>. Ти можеш пройтися тільки по іменах студентів (ключах), використовуючи for name in class_scores.keys()<\/strong>:. Якщо тобі потрібні лише самі оцінки (значення), використовуй for score in class_scores.values():<\/strong>. А якщо потрібна повна інформація (ім’я та оцінка разом) – використовуй for name, score in class_scores.items():<\/strong>.<\/p>\n

class_scores = {“Анна”: 95, “Олег”: 88, “Ірина”: 92}<\/em><\/p>\n

print(“Список студентів (тільки імена – ключі):”)<\/em><\/p>\n

for name in class_scores.keys():  # Перебираємо тільки ключі<\/em><\/p>\n

    print(name)<\/em><\/p>\n

Вивід<\/strong>:<\/p>\n

Список студентів (тільки імена – ключі):<\/p>\n

Анна<\/p>\n

Олег<\/p>\n

Ірина<\/p>\n

print(“nСписок оцінок (тільки значення):”)<\/em><\/p>\n

for score in class_scores.values():  # Перебираємо тільки значення<\/em><\/p>\n

    print(score)<\/em><\/p>\n

Вивід<\/strong>:<\/p>\n

Список оцінок (тільки значення):<\/p>\n

95<\/p>\n

88<\/p>\n

92<\/p>\n

print(“nПовна інформація про кожного студента (ім’я та оцінка):”)<\/em><\/p>\n

for name, score in class_scores.items():  # Перебираємо пари ключ-значення<\/em><\/p>\n

    print(f”Студент: {name}, Оцінка: {score}”)<\/em><\/p>\n

Вивід<\/strong>:<\/p>\n

Повна інформація про кожного студента (ім’я та оцінка):<\/em><\/p>\n

Студент: Анна, Оцінка: 95<\/em><\/p>\n

Студент: Олег, Оцінка: 88<\/em><\/p>\n

Студент: Ірина, Оцінка: 92<\/em><\/p>\n

Як бачиш, Python надає зручні інструменти для роботи з даними на будь-якій глибині!<\/p>\n

<\/source><\/source><\/source><\/source><\/picture><\/a>\n<\/p>\n

Складні сценарії використання словників Пайтон<\/h2>\n

\nУ реальному світі дані рідко бувають простими й плоскими. Часто вони мають складну, ієрархічну структуру. І тут Python зі своїми словниками в словниках та комбінаціями Пайтон<\/a> словники та списки показує себе у всій красі. Ти можеш моделювати практично будь-які дані, хай то відповідь від складного веб-API чи структура твого майбутнього проєкту, що є ключовою навичкою для будь-якого IT-спеціаліста.\n<\/p>\n

Словник у словнику Python<\/h3>\n

\nКоли значенням одного ключа є не просто число або рядок, а інший словник – це називається словник у словнику Пайтон (або словник словників Python). Така вкладеність дозволяє логічно групувати пов’язану інформацію і створювати деревоподібні структури даних, що дуже зручно для складних баз даних або конфігураційних файлів.<\/p>\n

Уяви дані про компанію, де є окремий блок для співробітників “employees”, а всередині нього – ще словники для кожного працівника. Щоб отримати посаду Джона, ти просто «пірнаєш» глибше по ключах, як по рівнях вкладеності:<\/p>\n

company_org_data = {<\/em><\/p>\n

    “company_name”: “GoIT Tech Solutions”,<\/em><\/p>\n

    “employees”: {  # Це вкладений словник, що зберігає інформацію про кожного працівника<\/em><\/p>\n

        “john_doe”: {“age”: 30, “position”: “Fullstack Developer”, “email”: “john.d@goit.global”},<\/em><\/p>\n

        “jane_smith”: {“age”: 28, “position”: “Data Analyst”, “email”: “jane.s@goit.global”}<\/em><\/p>\n

    },<\/em><\/p>\n

    “departments”: {<\/em><\/p>\n

        “it_development”: [“john_doe”],<\/em><\/p>\n

        “data_science”: [“jane_smith”]<\/em><\/p>\n

    },<\/em><\/p>\n

    “location”: “Київ”<\/em><\/p>\n

}<\/em><\/p>\n

print(f”Посада Джона: {company_org_data[’employees’][‘john_doe’][‘position’]}”)<\/em><\/p>\n

print(f”Email Джейн: {company_org_data[’employees’][‘jane_smith’][’email’]}”)<\/em><\/p>\n

Вивід<\/strong>:<\/p>\n

Посада Джона: Fullstack Developer  <\/em><\/p>\n

Email Джейн: jane.s@goit.global<\/em><\/p>\n

Така структура ідеально підходить для роботи з JSON-даними, які ти будеш отримувати від серверів, і вміння з ними працювати – це дуже цінна навичка.\n<\/p>\n

Python словники та списки<\/h3>\n

\nДуже часто ти будеш бачити, як Пайтон словники й списки «дружать» один з одним, створюючи неймовірно гнучкі та потужні структури даних. Наприклад, коли у словнику зберігається список (як список оцінок або список навичок), або коли список складається з багатьох словників (як список користувачів або товарів). Це типовий варіант для зберігання колекцій об’єктів, кожен з яких має унікальні властивості.<\/p>\n

Уяви, що це список курсів GoIT<\/a>, де кожен курс – це словник. Щоб отримати назву першого курсу, ти звертаєшся до першого елемента списку (індекс 0), а потім до словника за ключем ‘title’<\/strong>. А які технології вивчають на курсі з Data Science<\/a> (другий елемент у списку)? Спочатку звертайся до другого елемента списку (індекс 1), потім до словника за ключем ‘technologies’<\/strong>, а потім до першого елемента цього списку (індекс 0), бо ‘technologies’<\/strong>– це сам по собі список.<\/p>\n

goit_courses = [<\/em><\/p>\n

    {“title”: “Fullstack Developer”, “duration_weeks”: 32, “technologies”: [“Python”, “JavaScript”, “React”]},<\/em><\/p>\n

    {“title”: “Data Science”, “duration_weeks”: 28, “technologies”: [“Python”, “SQL”, “Pandas”]},<\/em><\/p>\n

    {“title”: “QA Engineer”, “duration_weeks”: 20, “technologies”: [“Python”, “Java”, “Testing tools”]}<\/em><\/p>\n

]<\/em><\/p>\n

print(f”Перший курс: {goit_courses[0][‘title’]}”)<\/em><\/p>\n

print(f”Одна з технологій Data Science: {goit_courses[1][‘technologies’][0]}”)<\/em><\/p>\n

Вивід<\/strong>:<\/p>\n

Перший курс: Fullstack Developer<\/a>  <\/em><\/p>\n

Одна з технологій Data Science: Python<\/em><\/p>\n

Такі комбінації дозволяють моделювати практично будь-які складні дані з реального світу, роблячи тебе по-справжньому популярним спеціалістом.<\/p>\n

\"\"
Хочеш вивчити Пайтон або іншу мову програмування? Тоді спробуй безплатні марафони<\/a> та курси GoIT<\/a>!<\/em><\/figcaption><\/figure>\n

Практичне застосування словників Python<\/h2>\n

\nРобота зі словником – це не просто теорія з підручника, а твій найпотужніший інструмент для розв’язання реальних задач в ІТ. Це ті навички, які ти будеш застосовувати щодня. Ось де словники сяють по-справжньому і чому знання про них – це твоя інвестиція в успішну кар’єру.<\/p>\n

По-перше, словники ідеальні для підрахунку частоти елементів: якщо тобі потрібно швидко підрахувати, скільки разів якесь слово зустрічається в тексті, символ у рядку або, наприклад, скільки разів користувач натиснув на певну кнопку – словники твої найкращі друзі! Вони дозволяють ефективно зберігати й оновлювати підрахунки для кожного унікального елемента, що є базовою операцією в аналізі даних.<\/p>\n

Наприклад, щоб підрахувати частоту символів у назві «GoIT – найкраще місце для старту в IT», ти можеш просто перебрати рядок і оновлювати відповідний лічильник у словнику, використовуючи char_frequency[char]<\/strong>.<\/p>\n

company_name = “GoIT – найкраще місце для старту в IT”<\/em><\/p>\n

char_frequency = {}<\/em><\/p>\n

for char in company_name:<\/em><\/p>\n

    char_frequency[char] = char_frequency.get(char, 0) + 1  # Якщо символ уже є, збільшуємо лічильник, інакше починаємо з 1<\/em><\/p>\n

print(f”Частота символів: {char_frequency}”)<\/em><\/p>\n

Вивід<\/strong>:<\/p>\n

Частота символів: {‘G’: 1, ‘o’: 1, ‘I’: 1, ‘T’: 2, ‘ ‘: 7, ‘–’: 1, ‘н’: 1, ‘а’: 3, ‘й’: 1, ‘к’: 1, ‘р’: 2, ‘щ’: 1, ‘е’: 3, ‘м’: 1, ‘і’: 2, ‘ц’: 1, ‘д’: 1, ‘л’: 1, ‘с’: 1, ‘т’: 2, ‘у’: 1, ‘в’: 1}<\/em><\/p>\n

По-друге, словники незамінні для зберігання конфігурацій. У будь-якому застосунку, грі або сервісі є налаштування – від розміру шрифту до шляхів до файлів баз даних. Часто всі ці параметри зберігаються саме у словниках, що забезпечує величезну гнучкість, легкий доступ до параметрів і зручне управління конфігурацією проєкту. Уяви, як легко отримати хост бази даних зі словника:<\/p>\n

app_config = {<\/em><\/p>\n

    “database”: {<\/em><\/p>\n

        “host”: “localhost”,<\/em><\/p>\n

        “port”: 5432,<\/em><\/p>\n

        “user”: “admin”,<\/em><\/p>\n

        “password”: “secure_password”<\/em><\/p>\n

    },<\/em><\/p>\n

    “app_settings”: {<\/em><\/p>\n

        “debug_mode”: True,<\/em><\/p>\n

        “log_level”: “INFO”,<\/em><\/p>\n

        “max_connections”: 100<\/em><\/p>\n

    }<\/em><\/p>\n

}<\/em><\/p>\n

print(f”Налаштування бази даних: Хост – {app_config[‘database’][‘host’]}, Порт – {app_config[‘database’][‘port’]}”)<\/em><\/p>\n

Вивід<\/strong>:<\/p>\n

Налаштування бази даних: Хост – localhost, Порт – 5432<\/em><\/p>\n

По-третє, словники дозволяють моделювати реальні об’єкти, втілюючи ідеї в коді. Уяви собі користувача в соціальній мережі, товар в інтернет-магазині або запис про студента в системі GoIT<\/a>. У кожного з них є набір унікальних характеристик (ім’я, вік, ціна, опис, список пройдених курсів). Словник ідеально підходить для їх зберігання, бо дозволяє присвоїти кожній властивості зрозуміле ім’я (ключ), роблячи код інтуїтивно зрозумілим і зручним для роботи. Робота зі словниками в таких сценаріях значно спрощує розробку і підтримку коду, дозволяючи тобі легко отримати, наприклад, ім’я студента або список пройдених модулів.<\/p>\n

student_record = {<\/em><\/p>\n

    “id”: “GOIT2025-001”,<\/em><\/p>\n

    “name”: “Віктор Петров”,<\/em><\/p>\n

    “course”: “Fullstack Developer”,<\/em><\/p>\n

    “enrollment_date”: “2024-09-01”,<\/em><\/p>\n

    “progress_percentage”: 75,<\/em><\/p>\n

    “completed_modules”: [“Python Basics”, “Web Fundamentals”, “Databases”]<\/em><\/p>\n

}<\/em><\/p>\n

print(f”Студент: {student_record[‘name’]}, Прогрес: {student_record[‘progress_percentage’]}%”)<\/em><\/p>\n

print(f”Модулі: {‘, ‘.join(student_record[‘completed_modules’])}”)<\/em><\/p>\n

Вивід<\/strong>:<\/p>\n

Студент: Віктор Петров, Прогрес: 75%<\/em><\/p>\n

Модулі: Python Basics, Web Fundamentals, Databases<\/em><\/p>\n

Бачиш, як просто описати складний об’єкт всього однією структурою!\n<\/p>\n

Що може бути ключем у словнику Пайтон<\/h2>\n

\nТи вже зрозумів, що ключі словника Python – це твої унікальні ідентифікатори, за якими ти знаходиш потрібну інформацію. Але є дуже важливе правило, яке потрібно запам’ятати, щоб уникнути помилок і писати надійний код, а саме – що може бути ключем у словнику Python<\/a>? Тільки незмінні (immutable) і хешовані (hashable) об’єкти.<\/p>\n

Розберімося, що це означає і чому це так важливо. Незмінні типи даних – це ті, значення яких не може бути змінене після створення. Подумай про це так: якби ключ міг змінитися, то Python не зміг би знайти його у словнику! До них належать: числа (цілі, дробові), рядки (найчастіше ключі в Python – це саме рядки, це зручно й зрозуміло!), кортежі (це як незмінні списки), а також логічні значення (True\/False) і NoneType (значення None).<\/p>\n

Хешовані типи даних – це ті, для яких можна обчислити спеціальне хеш-значення, унікальний числовий «відбиток». Python використовує ці хеш-значення для дуже швидкого пошуку ключів у словнику. Це як покажчик у книзі – він дозволяє миттєво перейти до потрібної сторінки. А ось списки та інші словники не можуть бути ключами, тому що вони є змінюваними (mutable) об’єктами. Їхній вміст може змінюватися, а якщо зміниться вміст ключа, то зміниться і його хеш-значення, що порушило б логіку швидкого пошуку. Запам’ятай це правило – воно збереже тобі багато часу й нервів у майбутніх проєктах!\n<\/p>\n

Висновки та твій наступний крок у світ IT: час діяти<\/h2>\n

\nВітаю! Тепер ти не просто знаєш, що таке словник у Пайтоні, ти розумієш його глибинну логіку і бачиш, як цей інструмент відкриває перед тобою величезні можливості!<\/p>\n

Твій шлях до опанування словника Python і його методів тільки починається, і ти вже зробив величезний крок, прочитавши цю статтю. Але найцікавіше попереду! Якщо ти хочеш не просто читати, а справді писати код, створювати проєкти й стати популярним спеціалістом, приходь на курси GoIT зі вивчення Пайтон – Python Software Engineering<\/a> та Python Data Science<\/a>. Вони дають не просто теорію, а реальні практичні навички, які незамінні для успішної кар’єри в IT!<\/p>\n","protected":false},"excerpt":{"rendered":"

\u041e\u043f\u0430\u043d\u043e\u0432\u0443\u0439 \u0441\u043b\u043e\u0432\u043d\u0438\u043a\u0438 \u041f\u0430\u0439\u0442\u043e\u043d \u0456 \u0432\u0456\u0434\u043a\u0440\u0438\u0439 \u0434\u0432\u0435\u0440\u0456 \u0434\u043e \u0435\u0444\u0435\u043a\u0442\u0438\u0432\u043d\u043e\u0457 \u0440\u043e\u0431\u043e\u0442\u0438 \u0437 \u0434\u0430\u043d\u0438\u043c\u0438. \u0414\u0456\u0437\u043d\u0430\u0439\u0441\u044f, \u044f\u043a \u0441\u0442\u0430\u0442\u0438 \u0441\u043f\u0440\u0430\u0432\u0436\u043d\u0456\u043c \u043f\u0440\u043e\u0444\u0456 \u0432 IT \u2013 \u0447\u0438\u0442\u0430\u0439 \u0441\u0442\u0430\u0442\u0442\u044e \u0432\u0456\u0434 GoIT!<\/p>\n","protected":false},"featured_media":40601,"menu_order":0,"template":"","meta":{"_acf_changed":false,"inline_featured_image":false},"categories":[12038],"tags":[],"class_list":["post-40611","articles","type-articles","status-publish","has-post-thumbnail","hentry","category-python-data-science"],"acf":[],"_links":{"self":[{"href":"https:\/\/goit.global\/ua\/wp-json\/wp\/v2\/articles\/40611","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/goit.global\/ua\/wp-json\/wp\/v2\/articles"}],"about":[{"href":"https:\/\/goit.global\/ua\/wp-json\/wp\/v2\/types\/articles"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/goit.global\/ua\/wp-json\/wp\/v2\/media\/40601"}],"wp:attachment":[{"href":"https:\/\/goit.global\/ua\/wp-json\/wp\/v2\/media?parent=40611"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/goit.global\/ua\/wp-json\/wp\/v2\/categories?post=40611"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/goit.global\/ua\/wp-json\/wp\/v2\/tags?post=40611"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}

Ти можеш додати ключ до словника Python<\/a> або здійснити додавання елементів до словника саме так, використовуючи просту операцію присвоєння. Як бачиш, додавання до словника Python максимально інтуїтивне і не вимагає виклику спеціальних методів для базових операцій.\n<\/p>\n