Разное

Питон словари: Словари (dict) и работа с ними. Методы словарей

Содержание

Словари (dict) и работа с ними. Методы словарей

Сегодня я расскажу о таком типе данных, как словари, о работе со словарями, операциях над ними, методах, о генераторах словарей.

Словари в Python — неупорядоченные коллекции произвольных объектов с доступом по ключу. Их иногда ещё называют ассоциативными массивами или хеш-таблицами.

Чтобы работать со словарём, его нужно создать. Создать его можно несколькими способами. Во-первых, с помощью литерала:

>>> d = {}
>>> d
{}
>>> d = {'dict': 1, 'dictionary': 2}
>>> d
{'dict': 1, 'dictionary': 2}

Во-вторых, с помощью функции dict:

>>> d = dict(short='dict', long='dictionary')
>>> d
{'short': 'dict', 'long': 'dictionary'}
>>> d = dict([(1, 1), (2, 4)])
>>> d
{1: 1, 2: 4}

В-третьих, с помощью метода fromkeys:

>>> d = dict.fromkeys(['a', 'b'])
>>> d
{'a': None, 'b': None}
>>> d = dict.fromkeys(['a', 'b'], 100)
>>> d
{'a': 100, 'b': 100}

В-четвертых, с помощью генераторов словарей, которые очень похожи на генераторы списков.

>>> d = {a: a ** 2 for a in range(7)}
>>> d
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}

Теперь попробуем добавить записей в словарь и извлечь значения ключей:

>>> d = {1: 2, 2: 4, 3: 9}
>>> d[1]
2
>>> d[4] = 4 ** 2
>>> d
{1: 2, 2: 4, 3: 9, 4: 16}
>>> d['1']
Traceback (most recent call last):
  File "", line 1, in
    d['1']
KeyError: '1'

Как видно из примера, присвоение по новому ключу расширяет словарь, присвоение по существующему ключу перезаписывает его, а попытка извлечения несуществующего ключа порождает исключение. Для избежания исключения есть специальный метод (см. ниже), или можно перехватывать исключение.

Что же можно еще делать со словарями? Да то же самое, что и с другими объектами: встроенные функции, ключевые слова (например, циклы for и while), а также специальные методы словарей.

Методы словарей

dict.clear() — очищает словарь.

dict.copy() — возвращает копию словаря.

classmethod dict.fromkeys(seq[, value]) — создает словарь с ключами из seq и значением value (по умолчанию None).

dict.get(key[, default]) — возвращает значение ключа, но если его нет, не бросает исключение, а возвращает default (по умолчанию None).

dict.items() — возвращает пары (ключ, значение).

dict.keys() — возвращает ключи в словаре.

dict.pop(key[, default]) — удаляет ключ и возвращает значение. Если ключа нет, возвращает default (по умолчанию бросает исключение).

dict.popitem() — удаляет и возвращает пару (ключ, значение). Если словарь пуст, бросает исключение KeyError. Помните, что словари неупорядочены.

dict.setdefault(key[, default]) — возвращает значение ключа, но если его нет, не бросает исключение, а создает ключ с значением default (по умолчанию None).

dict.update([other]) — обновляет словарь, добавляя пары (ключ, значение) из other. Существующие ключи перезаписываются. Возвращает None (не новый словарь!).

dict.values() — возвращает значения в словаре.

урок по работе со словарями для начинающих ~ PythonRu

Предыдущий урок: Множества (set)

Словарь — неупорядоченная последовательность, гибким к изменениям и индексированным. В Python словари пишутся в фигурных скобках, и состоят из ключей и значений.
Создадим и выведем словарь:

thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(thisdict)

Вывод:

{'brand': 'Ford', 'model': 'Mustang', 'year': 1964}

Доступ к элементам

Вы можете получить доступ к элементам словаря ссылаясь на его ключевое название.
Получим значение по ключу “model” :

x = thisdict["model"]

Существует так же метод под названием get() который даст вам тот же результат.

x = thisdict.get("model")

Изменить значение

Вы можете поменять значение указанного элемента ссылаясь на ключевое название.
Поменяем “year” на “2018”:

thisdict = {  
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict["year"] = 2018
print(thisdict)

Вывод:

{'brand': 'Ford', 'model': 'Mustang', 'year': 2018}

Цикл for по словарю

При проходе по словарю вы получите его ключи, но так же есть методы для возврата значений.
Выведем один за другим все ключи словаря:

for x in thisdict:
    print(x)

Вывод:

brand
model
year
Подписывайтесь на телеграм каналы

Выведем значения словаря, один за одним:

for x in thisdict:  
    print(thisdict[x])

Вывод:

Ford
Mustang
1964

Вы так же можете использовать функцию values() для возврата значений словаря:

for x in thisdict.values():
    print(x)

Вывод:

Ford
Mustang
1964

Пройдем по ключам и значениям, используя функцию items():

for x, y in thisdict.items():
    print(x, y)

Вывод:

brand Ford
model Mustang
year 1964

Длина словаря

Для того, чтобы определить сколько элементов есть в словаре, используйте метод len().

print(len(thisdict))

Вывод:

3

Добавление элементов

Добавление элементов в словарь выполняется с помощью нового ключа:

thisdict =  {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict["color"] = "red" 
print(thisdict)

Вывод:

{'brand': 'Ford', 'model': 'Mustang', 'year': 1964, 'color': 'red'}

Удаление элементов

Существует несколько методов удаления элементов из словаря.
Метод pop() удаляет элемент по ключу и возвращает его:

thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict.pop("model")

Метод popitem() удаляет последний элемент:

thisdict =  {
"brand": "Ford",
"model":  "Mustang",
"year":  1964
}
thisdict.popitem()

Ключевое слово del удаляет элемент по ключу:

thisdict =  {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
del thisdict["model"]
print(thisdict)

Вывод:

{'brand': 'Ford', 'year': 1964}

Ключевое слово del может так же удалить полностью весь словарь:

thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}  
del thisdict  
print(thisdict)  

Ключевое слово clear() очищает словарь:

thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict.clear()  
print(thisdict)

Вывод:

{}

Конструктор dict()

Вы так же можете использовать конструктор dict() для создания нового словаря.

thisdict = dict(brand="Ford", model="Mustang", year=1964)


print(thisdict)

Вывод:

{'brand': 'Ford', 'model': 'Mustang', 'year': 1964}

Методы словаря

В Python существует набор встроенных методов, с помощью которых вы можете работать со словарями.

Метод Значение
clear() Удаляет все элементы из словаря
copy() Делает копию словаря
fromkeys() Возвращает словарь с указанными ключами и значениями
get() Возвращает значение по ключу
items() Возвращает список, содержащий tuple для каждой пары ключ-значение
keys() Возвращает список, содержащий ключи словаря
pop() Удаляет элементы по ключу
popitem() Удаляет последнюю пару ключа со значением
setdefault() Задает значение по ключу. Если ключа нет в словаре, добавляет его с указанным значением или None
update() Обновляет словарь, добавляя пары ключ-значение
values() Возвращает список всех значений в словаре

Далее: Условные выражения и конструкция if

15 вещей, которые нужно знать о словарях Python

Словари в Python – это изменяемые отображения
ссылок на объекты, доступные
по ключу. Словари
представляют собой структуры
данных, в которых уникальные
ключи отображают значения. Ключ и значение разделяются двоеточием, пары ключ-значения отделяются запятыми, а словарь целиком ограничивается фигурными скобками {}. Ниже
приведены три словаря, содержащие
сведения о населении пяти крупнейших городов
Германии, список покупок и оценки студентов.

        >>> population = {'Berlin': 3748148, 'Hamburg': 1822445, 'Munich': 1471508, 'Cologne': 1085664, 'Frankfurt': 753056 }
>>> products = {'table': 120, 'chair': 40, 'lamp': 14, 'bed': 250, 'mattress': 100}
>>> grades = {'Alba': 9.5, 'Eduardo': 10, 'Normando': 3.5, 'Helena': 6.5, 'Claudia': 7.5}
    

Три этих словаря будут использоваться далее в руководстве. Чтобы лучше разобраться в теме словарей, советуем проходить этот текст вместе с интерпретатором Python.

Кроме прямого описания, словари также можно создавать с помощью
встроенной функции dict(). Эта функция
принимает любое
количество именованных
аргументов.

        >>> students_ages = dict(Amanda=27, Teresa=38, Paula=17, Mario=40)
>>> print(students_ages)
{'Amanda': 27, 'Teresa': 38, 'Paula': 17, 'Mario': 40}

    

Методы можно комбинировать:

        >>> students_ages = dict({'Amanda': 27, 'Teresa': 38}, Paula=17, Mario=40)
>>> print(students_ages)
{'Amanda': 27, 'Teresa': 38, 'Paula': 17, 'Mario': 40}
    

Другой вариант – использовать список
кортежей. Каждый кортеж
должен содержать два объекта: ключ и значение.

        >>> students_ages = dict([('Amanda', 27), ('Teresa', 38), ('Paula', 17), ('Mario', 40)])
>>> print(students_ages)
{'Amanda': 27, 'Teresa': 38, 'Paula': 17, 'Mario': 40}

    

Наконец, можно создать словарь,
используя два списка. Вначале строим итератор кортежей с
помощью функции zip(). Затем используем ту же функцию dict() для построения
словаря.

        >>> students = ['Amanda', 'Teresa', 'Paula', 'Mario']
>>> ages = [27, 38, 17, 40]
>>> students_ages = dict(zip(students, ages))
>>> print(students_ages)
{'Amanda': 27, 'Teresa': 38, 'Paula': 17, 'Mario': 40}
    

Для доступа к значениям
словаря мы
не можем использовать числовой индекс
(как в случае со списками или кортежами). Однако схема извлечения значения похожа на индексацию: вместо числа в квадратные скобки подставляется ключ. При попытке получить доступ к значению с
помощью несуществующего ключа будет вызвана ошибка KeyError.

Чтобы избежать получения
исключения с несуществующими
ключами, можно воспользоваться методом
dict.get(key[, default]). Этот метод возвращает
значение для ключа, если ключ находится
в словаре, иначе возвращает значение
по умолчанию default. Если значение по умолчанию
не задано, метод возвращает None (но никогда не возвращает
исключение).

        >>> print(population['Munich'])
1471508
>>> print(population[1])
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 1
>>> print(population['Stuttgart'])
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 'Stuttgart'
>>> print(population.get('Munich'))
1471508
>>> print(population.get('Stuttgart'))
None
>>> print(population.get('Stuttgart', 'Not found'))
Not found
    

Добавить одиночный элемент в
словарь можно следующим образом:

        >>> products['pillow'] = 10
>>> print(products)
{'table': 120, 'chair': 40, 'lamp': 14, 'bed': 250, 'mattress': 100, 'pillow': 10}

    

Для добавления
нескольких элементов одновременно можно применять метод dict.update([other]). Он обновляет словарь парами
ключ-значение из other,
перезаписывая существующие ключи.

        >>> products.update({'shelf': 70, 'sofa': 300})
>>> print(products)
{'table': 120, 'chair': 40, 'lamp': 14, 'bed': 250, 'mattress': 100, 'pillow': 10, 'shelf': 70, 'sofa': 300}
>>> grades.update(Violeta=5.5, Marco=6.5, Paola=8)
>>> print(grades)
{'Alba': 9.5, 'Eduardo': 10, 'Normando': 3.5, 'Helena': 6.5, 'Claudia': 7.5, 'Violeta': 5.5, 'Marco': 6.5, 'Paola': 8}
>>> population.update([('Stuttgart', 632743), ('Dusseldorf', 617280)])
>>> print(population)
{'Berlin': 3748148, 'Hamburg': 1822445, 'Munich': 1471508, 'Cologne': 1085664, 'Frankfurt': 753056, 'Stuttgart': 632743, 'Dusseldorf': 617280}
    

Как показано выше, метод
update() может принимать в качестве аргумента
не только словарь, но и список
кортежей или именованные
аргументы.

Изменим значение
элемента, обратившись к ключу с помощью
квадратных скобок ([]). Для изменения
нескольких значений сразу есть метод .update(). Он перезаписывает существующие
ключи.

Увеличим цену дивана на 100
единиц и изменим
оценки двух студентов.

        >>> print(products)
{'table': 120, 'chair': 40, 'lamp': 14, 'bed': 250, 'mattress': 100, 'pillow': 10, 'shelf': 70, 'sofa': 300}
>>> products['sofa'] = 400
>>> print(products)
{'table': 120, 'chair': 40, 'lamp': 14, 'bed': 250, 'mattress': 100, 'pillow': 10, 'shelf': 70, 'sofa': 400}
>>> print(grades)
{'Alba': 9.5, 'Eduardo': 10, 'Normando': 3.5, 'Helena': 6.5, 'Claudia': 7.5, 'Violeta': 5.5, 'Marco': 6.5, 'Paola': 8}
>>> grades.update({'Normando': 2.5, 'Violeta': 6})
>>> print(grades)
{'Alba': 9.5, 'Eduardo': 10, 'Normando': 2.5, 'Helena': 6.5, 'Claudia': 7.5, 'Violeta': 6, 'Marco': 6.5, 'Paola': 8}
    

Для удаления элемента из
словаря можно использовать либо del
dict[key]
, либо dict.pop(key[, default]). В первом случае из словаря удаляется соответствующая пара. Или, если такого ключа нет, возвращается KeyError.

        >>> print(population)
{'Berlin': 3748148, 'Hamburg': 1822445, 'Munich': 1471508, 'Cologne': 1085664, 'Frankfurt': 753056, 'Stuttgart': 632743, 'Dusseldorf': 617280}
>>> del population['Ingolstadt']
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 'Ingolstadt'
>>> del population['Dusseldorf']
>>> print(population)
{'Berlin': 3748148, 'Hamburg': 1822445, 'Munich': 1471508, 'Cologne': 1085664, 'Frankfurt': 753056, 'Stuttgart': 632743}
    

Метод dict.pop(key[,
default])
удаляет из словаря
элемент с заданным ключом и возвращает
его значение. Если ключ
отсутствует, метод возвращает
значение default
. Если значение default не задано и ключа не существует, метод
pop() вызовет исключение KeyError.

        >>> print(population)
{'Berlin': 3748148, 'Hamburg': 1822445, 'Munich': 1471508, 'Cologne': 1085664, 'Frankfurt': 753056, 'Stuttgart': 632743}
>>> population.pop('Stuttgart')
632743
>>> print(population)
{'Berlin': 3748148, 'Hamburg': 1822445, 'Munich': 1471508, 'Cologne': 1085664, 'Frankfurt': 753056}
>>> print(population.pop('Ingolstadt', 'Value not found'))
Value not found
>>> population.pop('Garching')
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 'Garching'
    

Чтобы проверить, существует ли ключ
в словаре, достаточно воспользоваться операторами принадлежности:

        >>> print(population)
{'Berlin': 3748148, 'Hamburg': 1822445, 'Munich': 1471508, 'Cologne': 1085664, 'Frankfurt': 753056}
>>> print('Ingolstadt' in population)
False
>>> print('Munich' in population)
True
>>> print('Ingolstadt' not in population)
True
>>> print('Munich' not in population)
False
    

Чтобы скопировать словарь, можно использовать метод словаря copy(). Этот метод возвращает
поверхностную
копию словаря. Мы должны
быть осторожны с такими
копиями: если словарь содержит списки, кортежи
или множества,
то в созданной
копии будут только ссылки на объекты
из оригинала.

        >>> students = {'Marco': 173, 'Luis': 184, 'Andrea': 168}
>>> students_2 = students.copy()  # поверхностная копия
>>> students_2['Luis'] = 180
>>> print(students)
{'Marco': 173, 'Luis': 184, 'Andrea': 168}
>>> print(students_2)
{'Marco': 173, 'Luis': 180, 'Andrea': 168}
>>> students_weights = {'Marco': [173, 70], 'Luis': [184, 80], 'Andrea': [168, 57]}
>>> students_weights_2 = students_weights.copy()
>>> students_weights_2['Luis'][0] = 180
>>> print(students_weights)
{'Marco': [173, 70], 'Luis': [180, 80], 'Andrea': [168, 57]}
    

Изменение в списке students_2 затронуло список students, так как список, содержащий вес и рост, содержит ссылки, а не дубликаты. Чтобы избежать этой проблемы,
создадим
глубокую копию, используя функцию
copy.deepcopy(x):

        >>> import copy
>>> students_weights = {'Marco': [173, 70], 'Luis': [184, 80], 'Andrea': [168, 57]}
>>> students_weights_2 = copy.deepcopy(students_weights)
>>> students_weights_2['Luis'][0] = 180
>>> print(students_weights)
{'Marco': [173, 70], 'Luis': [184, 80], 'Andrea': [168, 57]}
>>> print(students_weights_2)
{'Marco': [173, 70], 'Luis': [180, 80], 'Andrea': [168, 57]}
    

При использовании глубокого
копирования создается полностью
независимая копия.

Важно помнить, что оператор
= не
создаёт копию словаря. Он
присваивает другое имя,
но относящееся
к тому же словарю, т. е.
любое
изменение нового словаря
отражается на
исходном.

        >>> fruits = {'Orange': 50, 'Apple': 65, 'Avocado': 160, 'Pear': 75}
>>> fruits_2 = fruits
>>> fruits_2.pop('Orange')
50
>>> print(fruits)
{'Apple': 65, 'Avocado': 160, 'Pear': 75}
    

Чтобы выяснить сколько пар
ключ-значение содержится в словаре, достаточно воспользоваться функцией len():

        >>> print(population)
{'Berlin': 3748148, 'Hamburg': 1822445, 'Munich': 1471508, 'Cologne': 1085664, 'Frankfurt': 753056}
>>> print(len(population))
5
    

10.1 Итерация
ключей

Чтобы перебрать все ключи, достаточно провести итерацию по элементам объекта словаря:

        >>> for city in population:
...     print(city)
... 
Berlin
Hamburg
Munich
Cologne
Frankfurt
    

10.2 Итерация
значений

Вычислим
сколько людей проживает в пяти крупнейших
городах Германии. Применим метод dict.values(), возвращающий список значений словаря:

        >>> print(population)
{'Berlin': 3748148, 'Hamburg': 1822445, 'Munich': 1471508, 'Cologne': 1085664, 'Frankfurt': 753056}
>>> inhabitants = 0
>>> for number in population.values():
...     inhabitants += number
... 
>>> print(inhabitants)
8880821
    

В пяти крупнейших городах Германии живут почти 9 миллионов человек.

10.3 Итерация
ключей и
значений

В
случае, если нужно работать
с ключами и значениями одновременно, обратимся к методу
dict.items(),
возвращающему пары ключ-значение в
виде списка кортежей.

        >>> min_grade = 10
>>> min_student = ''
>>> for student, grade in grades.items():
...     if grade < min_grade:
...             min_student = student
...             min_grade = grade
... 
>>> print(min_student)
Normando
    

Цикл
for удобен,
но
сейчас попробуем более эффективный и
быстрый способ – генератор словарей.
Синтаксис выглядит так: {key:
value for vars in iterable}

Отфильтруем товары из словаря products по цене ниже 100 евро, используя
как цикл for,
так и генератор словарей.

        >>> print(products)
{'table': 120, 'chair': 40, 'lamp': 14, 'bed': 250, 'mattress': 100, 'pillow': 10, 'shelf': 70, 'sofa': 400}
>>> products_low = {}
>>> for product, value in products.items():
...     if value < 100:
...             products_low.update({product: value})
... 
>>> print(products_low)
{'chair': 40, 'lamp': 14, 'pillow': 10, 'shelf': 70}
>>> products_low = {product: value for product, value in products.items() if value < 100}
>>> print(products_low)
{'chair': 40, 'lamp': 14, 'pillow': 10, 'shelf': 70}
    

Результаты
идентичны, при этом генератор словарей
записан компактнее.

Вложенные
словари – это
словари, содержащие другие словари. Мы
можем создать вложенный словарь так
же, как мы создаем обычный словарь,
используя фигурные скобки.

Следующий
вложенный словарь содержит информацию
о пяти известных произведениях искусства.
Как можно заметить, значениями
словаря являются другие словари.

        # вложенный словарь, содержащий информацию об известных произведениях искусства
works_of_art = {'The_Starry_Night': {'author': 'Van Gogh', 'year': 1889, 'style': 'post-impressionist'},
                'The_Birth_of_Venus': {'author': 'Sandro Botticelli', 'year': 1480, 'style': 'renaissance'},
                'Guernica': {'author': 'Pablo Picasso', 'year': 1937, 'style': 'cubist'},
                'American_Gothic': {'author': 'Grant Wood', 'year': 1930, 'style': 'regionalism'},
                'The_Kiss': {'author': 'Gustav Klimt', 'year': 1908, 'style': 'art nouveau'}}
    

Создадим вложенный словарь,
используя dict(), передавая пары
ключ-значение
в
качестве именованных
аргументов.

        # вложенный словарь, созданный при помощи dict()
works_of_art = dict(The_Starry_Night={'author': 'Van Gogh', 'year': 1889, 'style': 'post-impressionist'},
                    The_Birth_of_Venus={'author': 'Sandro Botticelli', 'year': 1480, 'style': 'renaissance'},
                    Guernica={'author': 'Pablo Picasso', 'year': 1937, 'style': 'cubist'},
                    American_Gothic={'author': 'Grant Wood', 'year': 1930, 'style': 'regionalism'},
                    The_Kiss={'author': 'Gustav Klimt', 'year': 1908, 'style': 'art nouveau'})

    

Для
доступа к элементам во вложенном словаре указываем ключи, используя несколько
квадратных скобок ([ ][ ]).

        >>> print(works_of_art['Guernica']['author'])
Pablo Picasso
>>> print(works_of_art['American_Gothic']['style'])
regionalism
    

Модуль
collections
предоставляет альтернативные типы
данных: OrderedDict,
defaultdict и
Counter, расширяющие возможности обычных словарей. У нас есть подробная статья о модуле collections, которая помогает не изобретать уже известные структуры данных Python. Здесь мы остановимся на трех типах данных, наиболее близких к словарям.

13.1. OrderedDict

OrderedDict
содержит
словарь, хранящий порядок добавления
ключей. В
Python 3.6+ словари запоминают порядок,
а
для предыдущих
версий Python можно использовать OrderedDict.

        >>> import collections
>>> dictionary = collections.OrderedDict({'hydrogen': 1, 'helium': 2, 'carbon': 6, 'oxygen': 8})
>>> print(type(dictionary))

    

С
OrderedDict
можно
использовать
операции
с элементами, методы и
функции, как при
работе с
обычным словарем.

13.2. defaultdict

defaultdict – подкласс
словаря, присваивающий
значение
по умолчанию при отсутствии ключа. Он
никогда не выдаст
KeyError,
если
мы попробуем
получить
доступ к элементу, который отсутствует
в словаре. Будет
создана новая запись. В приведенном ниже примере
ключи создаются с
различными значениями в зависимости
от функции, используемой в качестве
первого аргумента.

        >>> default_1 = collections.defaultdict(int)
>>> default_1['missing_entry']
0
>>> print(default_1)
defaultdict(, {'missing_entry': 0})
>>> default_2 = collections.defaultdict(list, {'a': 1, 'b': 2})
>>> default_2['missing_entry']
[]
>>> print(default_2)
defaultdict(, {'a': 1, 'b': 2, 'missing_entry': []})
>>> default_3 = collections.defaultdict(lambda : 'Not given', a=1, b=2)
>>> default_3['missing_entry']
'Not given'
>>> print(default_3)
defaultdict( at 0x7f75d97d6840>, {'a': 1, 'b': 2, 'missing_entry': 'Not given'})
>>> import numpy as np
>>> default_4 = collections.defaultdict(lambda: np.zeros(2))
>>> default_4['missing_entry']
array = ([0., 0.])
>>> print(default_4)
defaultdict( at 0x7f75bf7198c8>, {'missing_entry': array([0., 0.])})
    

13.3. Counter

Counter – подкласс
словаря, подсчитывающий
объекты хеш-таблицы.
Функция возвращает объект Counter,
в
котором элементы хранятся как ключи, а
их количество в виде значений. Эта функция позволяет подсчитать элементы
списка:

        >>> letters = ['a', 'a', 'c', 'a', 'a', 'b', 'c', 'a']
>>> counter = collections.Counter(letters)
>>> print(counter)
Counter({'a': 5, 'c': 2, 'b': 1})
>>> print(counter.most_common(2))
[('a', 5), ('c', 2)]
    

Как
показано выше, мы можем легко получить
наиболее часто используемые элементы
с помощью метода most_common([n]). Этот метод
возвращает список n наиболее часто
встречающихся элементов и их количество.

Pandas
DataFrame – это
двумерная
таблица
со
строками и столбцами, создаваемая в библиотеке анализа данных pandas. Это очень мощная библиотека для работы с данными. Ранее мы рассказывали как можно анализируовать данные с помощью одной строки на Python в pandas (да и вообще о разных трюках работы с библиотекой).

Объект DataFrame
создается
с помощью функции pandas.DataFrame(),
принимающей различные типы данных
(списки, словари, массивы numpy).
В этой статье разберем
только те способы создания датафрейма, которые
предполагают использование словарей.

14.1. Создание DataFrame из
словаря

Создадим DataFrame из словаря,
где ключами
будут имена столбцов,
а значениями – данные столбцов:

        import pandas as pd

# создать Pandas DataFrame из словаря - ключ (название столбца) - значение (информация в столбце)
df = pd.DataFrame({'name': ['Mario', 'Violeta', 'Paula'],
                     'age': [22, 27, 19],
                     'grades': [9, 8.5, 7]})

print(df)
    

По умолчанию индексом
является номер строки (целое число,
начинающееся с 0). Изменим
индексы, передав список индексов
в DataFrame.

        # создать Pandas DataFrame из словаря - ключ (название столбца) - значение (информация в столбце) - с собственными индексами
import pandas as pd

df_index = pd.DataFrame({'name': ['Mario', 'Violeta', 'Paula'],
                     'age': [22, 27, 19],
                     'grades': [9, 8.5, 7]}, index=['student_1', 'student_2', 'student_3'])


print(df_index)
    

14.2. Создание DataFrame из
списка словарей

Список словарей также может быть
использован для создания DataFrame, где
ключи – имена
столбцов. Как и раньше, мы можем изменять
индексы, передавая список индексов в
функцию DataFrame.

        # создать Pandas DataFrame из списка словарей - ключи (названия столбцов) с собственными индексами
import pandas as pd

df_2 = pd.DataFrame([{'name': 'Mario', 'age': 22, 'grades':9},
                     {'name': 'Violeta', 'age': 27, 'grades':8.5},
                     {'name': 'Paula', 'age': 19, 'grades':7}], index=['student_1', 'student_2', 'student_3'])

print(df_2)
    

В Pandas есть несколько функций, использующих
словари в качестве входных значений,
например, pandas.DataFrame.rename
и
pandas.DataFrame.replace.

15.1. pandas.DataFrame.rename

Эта функция возвращает DataFrame с
переименованными метками осей. На
вход можно подать
словарь, в котором ключи – старые имена, а значения – новые. Метки,
не содержащиеся в словаре, остаются
неизменными.

        # изменить метки индекса в df_2
import pandas as pd

df_2 = pd.DataFrame([{'name': 'Mario', 'age': 22, 'grades':9},
                     {'name': 'Violeta', 'age': 27, 'grades':8.5},
                     {'name': 'Paula', 'age': 19, 'grades':7}], index=['student_1', 'student_2', 'student_3'])

df_2.rename(index={'student_1': 'new_label_1', 'student_2': 'new_label_2'}, inplace=True)

print(df_2)
    

15.2. pandas.DataFrame.replace

Эта функция меняет значения
DataFrame на другие значения.
Мы можем использовать
словарь с функцией замены для изменения
DataFrame, где ключи представляют
собой
существующие записи, а значения –
новые.

        # заменить Mario --> Maria и Paula --> Paola
import pandas as pd

df_2 = pd.DataFrame([{'name': 'Mario', 'age': 22, 'grades':9},
                     {'name': 'Violeta', 'age': 27, 'grades':8.5},
                     {'name': 'Paula', 'age': 19, 'grades':7}], index=['student_1', 'student_2', 'student_3'])
df_2.replace({'Mario': 'Maria', 'Paula': 'Paola'}, inplace=True)

print(df_2)

    

***

Итак, мы рассмотрели разные способы создания словаря, базовые операции (добавление, изменение, удаление элементов). Также мы узнали когда стоит использовать глубокую копию словаря вместо поверхностной. Научились строить матрёшки – вложенные словари. Такие конструкции встретятся, когда вы будете качать, например, с ВКонтакте через его API разнообразную информацию.

Если вы любите Python, Библиотека программиста подготовила ещё много интересных материалов об этом замечательном языке:

Свежие материалы доступны по тегу Python.

Полное руководство по словарям в Python

Подписывайся на наш канал в Telegram, чтобы ежедневно совершенствоваться в Python. Там выходят задачи, полезные советы и сливы платных курсов — перейти

Python предоставляет еще один составной тип данных, называемый словарем, который похож на список в том, что представляет собой набор объектов.

Вот что вы узнаете из этого руководства: вы узнаете об основных характеристиках словарей Python и то, как получить доступ к данным словаря и управлять ими. После того, как вы закончите это руководство, вы должны хорошо понимать, когда словарь является подходящим типом данных для использования и как это реализовать.

Словари и списки имеют следующие характеристики:

  • Оба непостоянны.
  • Оба динамичны. Они могут увеличиваться и уменьшаться по мере необходимости.
  • Оба могут быть вложенными. Список может содержать другой список. Словарь может содержать другой словарь. Словарь также может содержать список, и наоборот.

Словари отличаются от списков в первую очередь способом доступа к элементам:

  • Доступ к элементам списка осуществляется по их положению в списке посредством индексации.
  • Доступ к элементам словаря осуществляется с помощью ключей.

Определение словаря

Словари – это реализация Python структуры данных, более известной как ассоциативный массив. Словарь состоит из набора пар ключ-значение. Каждая пара “ключ-значение” сопоставляет ключ с соответствующим значением.

Вы можете определить словарь, заключив список пар ключ-значение, разделенных запятыми, в фигурные скобки ({}). Двоеточие (:) отделяет каждый ключ от связанного с ним значения:

d = {
    <key>: <value>,
    <key>: <value>,
      .
      .
      .
    <key>: <value>
}

Следующее определяет словарь, который сопоставляет местоположение с названием соответствующей команды Высшей бейсбольной лиги:

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Twins',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners'
... }

Сопоставление местоположения словаря с командой MLB

Вы также можете создать словарь с помощью встроенной функции dict(). Аргумент dict() должен быть последовательностью пар ключ-значение. Для этого хорошо подходит список кортежей:

d = dict([
    (<key>, <value>),
    (<key>, <value),
      .
      .
      .
    (<key>, <value>)
])

MLB_team также можно определить следующим образом:

>>> MLB_team = dict([
...     ('Colorado', 'Rockies'),
...     ('Boston', 'Red Sox'),
...     ('Minnesota', 'Twins'),
...     ('Milwaukee', 'Brewers'),
...     ('Seattle', 'Mariners')
... ])

Если значения ключа являются простыми строками, их можно указать как аргументы ключевого слова. Итак, вот еще один способ определить MLB_team:

>>> MLB_team = dict(
...     Colorado='Rockies',
...     Boston='Red Sox',
...     Minnesota='Twins',
...     Milwaukee='Brewers',
...     Seattle='Mariners'
... )

После того, как вы определили словарь, вы можете отобразить его содержимое так же, как и для списка. Все три приведенных выше определения при отображении выглядят следующим образом:

>>> type(MLB_team)
<class 'dict'>

>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners'}

Записи в словаре отображаются в том порядке, в котором они были определены. Но когда дело доходит до их получения, это не имеет значения. Доступ к элементам словаря не осуществляется по числовому индексу:

>>> MLB_team[1]
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    MLB_team[1]
KeyError: 1

Доступ к значениям словаря

Конечно, элементы словаря должны быть как-то доступны. Если вы не получите их по индексу, то как их получить?

Значение извлекается из словаря путем указания соответствующего ключа в квадратных скобках ([]):

>>> MLB_team['Minnesota']
'Twins'
>>> MLB_team['Colorado']
'Rockies'

Если вы ссылаетесь на ключ, которого нет в словаре, Python вызывает исключение:

>>> MLB_team['Toronto']
Traceback (most recent call last):
  File "<pyshell#19>", line 1, in <module>
    MLB_team['Toronto']
KeyError: 'Toronto'

Добавление записи в существующий словарь – это просто вопрос назначения нового ключа и значения:

>>> MLB_team['Kansas City'] = 'Royals'
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners', 'Kansas City': 'Royals'}

Если вы хотите обновить запись, вы можете просто присвоить новое значение существующему ключу:

>>> MLB_team['Seattle'] = 'Seahawks'
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Seahawks', 'Kansas City': 'Royals'}

Чтобы удалить запись, используйте оператор del, указав ключ для удаления:

>>> del MLB_team['Seattle']
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Kansas City': 'Royals'}

Беги, Сихокс! Ты команда НФЛ.

Ключи словаря и индексы списка

Вы могли заметить, что интерпретатор вызывает то же исключение, KeyError, когда к словарю обращаются либо с неопределенным ключом, либо по числовому индексу:

>>> MLB_team['Toronto']
Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    MLB_team['Toronto']
KeyError: 'Toronto'

>>> MLB_team[1]
Traceback (most recent call last):
  File "<pyshell#9>", line 1, in <module>
    MLB_team[1]
KeyError: 1

По сути, это та же ошибка. В последнем случае [1] выглядит как числовой индекс, но это не так.

Позже в этом руководстве вы увидите, что объект любого неизменяемого типа может использоваться как ключ словаря. Соответственно, нет причин, по которым вы не можете использовать целые числа:

>>> d = {0: 'a', 1: 'b', 2: 'c', 3: 'd'}
>>> d
{0: 'a', 1: 'b', 2: 'c', 3: 'd'}

>>> d[0]
'a'
>>> d[2]
'c'

В выражениях MLB_team [1], d [0] и d [2] числа в квадратных скобках выглядят так, как если бы они могли быть индексами. Но они не имеют ничего общего с порядком пунктов в словаре. Python интерпретирует их как ключи словаря. Если вы определите этот же словарь в обратном порядке, вы все равно получите те же значения, используя те же ключи:

>>> d = {3: 'd', 2: 'c', 1: 'b', 0: 'a'}
>>> d
{3: 'd', 2: 'c', 1: 'b', 0: 'a'}

>>> d[0]
'a'
>>> d[2]
'c'

Синтаксис может быть похожим, но словарь нельзя рассматривать как список:

>>> type(d)
<class 'dict'>

>>> d[-1]
Traceback (most recent call last):
  File "<pyshell#30>", line 1, in <module>
    d[-1]
KeyError: -1

>>> d[0:2]
Traceback (most recent call last):
  File "<pyshell#31>", line 1, in <module>
    d[0:2]
TypeError: unhashable type: 'slice'

>>> d.append('e')
Traceback (most recent call last):
  File "<pyshell#32>", line 1, in <module>
    d.append('e')
AttributeError: 'dict' object has no attribute 'append'

Примечание. Хотя доступ к элементам в словаре не зависит от порядка, Python гарантирует, что порядок элементов в словаре сохраняется. При отображении элементы будут отображаться в том порядке, в котором они были определены, и повторение ключей также будет происходить в этом порядке. Элементы, добавленные в словарь, добавляются в конце. Если элементы удаляются, порядок остальных элементов сохраняется.

На такое сохранение порядка можно рассчитывать лишь совсем недавно. Он был добавлен как часть спецификации языка Python в версии 3.7. Однако это было верно и для версии 3.6 – случайно, в результате реализации, но не гарантированной спецификацией языка.

Постепенное создание словаря

Определение словаря с помощью фигурных скобок и списка пар ключ-значение, как показано выше, нормально, если вы заранее знаете все ключи и значения. Но что, если вы хотите создать словарь на лету?

Вы можете начать с создания пустого словаря, который определяется пустыми фигурными скобками. Затем вы можете добавлять новые ключи и значения по одному:

>>> person = {}
>>> type(person)
<class 'dict'>

>>> person['fname'] = 'Joe'
>>> person['lname'] = 'Fonebone'
>>> person['age'] = 51
>>> person['spouse'] = 'Edna'
>>> person['children'] = ['Ralph', 'Betty', 'Joey']
>>> person['pets'] = {'dog': 'Fido', 'cat': 'Sox'}

После создания словаря таким образом доступ к его значениям осуществляется так же, как и к любому другому словарю:

>>> person
{'fname': 'Joe', 'lname': 'Fonebone', 'age': 51, 'spouse': 'Edna',
'children': ['Ralph', 'Betty', 'Joey'], 'pets': {'dog': 'Fido', 'cat': 'Sox'}}

>>> person['fname']
'Joe'
>>> person['age']
51
>>> person['children']
['Ralph', 'Betty', 'Joey']

Для получения значений в подсписке или подсловаре требуется дополнительный индекс или ключ:

>>> person['children'][-1]
'Joey'
>>> person['pets']['cat']
'Sox'

В этом примере демонстрируется еще одна особенность словарей: значения, содержащиеся в словаре, не обязательно должны быть одного типа. Лично некоторые значения являются строками, одно – целым числом, одно – списком, а третье – другим словарем.

Точно так же, как значения в словаре не обязательно должны быть одного типа, ключи также не должны:

>>> foo = {42: 'aaa', 2.78: 'bbb', True: 'ccc'}
>>> foo
{42: 'aaa', 2.78: 'bbb', True: 'ccc'}

>>> foo[42]
'aaa'
>>> foo[2.78]
'bbb'
>>> foo[True]
'ccc'

Здесь один из ключей – целое число, один – число с плавающей запятой, а третий – логическое. Неизвестно, насколько это может быть полезно, но мало ли.

Обратите внимание, насколько универсальны словари Python. В MLB_team одна и та же информация (название бейсбольной команды) хранится для каждого из нескольких различных географических мест. person, с другой стороны, хранит различные типы данных для одного человека.

Вы можете использовать словари для самых разных целей, потому что существует очень мало ограничений на разрешенные ключи и значения. Но такие есть. Читай дальше!

Ограничения для ключей словаря

Почти любой тип значения может использоваться в качестве словарного ключа в Python. Вы только что видели этот пример, где в качестве ключей используются целочисленные, плавающие и логические объекты:

>>> foo
{42: 'aaa', 2.78: 'bbb', True: 'ccc'}

Вы даже можете использовать встроенные объекты, такие как типы и функции:

>>> d = {int: 1, float: 2, bool: 3}
>>> d
{<class 'int'>: 1, <class 'float'>: 2, <class 'bool'>: 3}
>>> d[float]
2

>>> d = {bin: 1, hex: 2, oct: 3}
>>> d[oct]
3

Однако есть пара ограничений, которым должны соответствовать словарные ключи.

Во-первых, данный ключ может появиться в словаре только один раз. Повторяющиеся ключи не допускаются. Словарь сопоставляет каждый ключ с соответствующим значением, поэтому нет смысла сопоставлять конкретный ключ более одного раза.

Вы видели выше, что когда вы присваиваете значение уже существующему ключу словаря, он не добавляет ключ во второй раз, а заменяет существующее значение:

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Twins',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners'
... }

>>> MLB_team['Minnesota'] = 'Timberwolves'
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Timberwolves',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners'}

Точно так же, если вы укажете ключ во второй раз во время первоначального создания словаря, второе вхождение заменит первое:

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Timberwolves',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners',
...     'Minnesota': 'Twins'
... }
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners'}

Прочь, Timberwolves! Вы команда НБА. Вроде, как бы, что-то вроде того.

Во-вторых, ключ словаря должен иметь неизменяемый тип. Вы уже видели примеры, в которых несколько знакомых вам неизменяемых типов – integer, float, string и Boolean – служили ключами словаря.

Кортеж также может быть ключом словаря, потому что кортежи неизменяемы:

>>> d = {(1, 1): 'a', (1, 2): 'b', (2, 1): 'c', (2, 2): 'd'}
>>> d[(1,1)]
'a'
>>> d[(2,1)]
'c'

(Вспомните из обсуждения кортежей, что одно из объяснений использования кортежа вместо списка заключается в том, что существуют обстоятельства, при которых требуется неизменяемый тип. Это одно из них.)

Однако ни список, ни другой словарь не могут служить ключом словаря, потому что списки и словари изменяемы:

>>> d = {[1, 1]: 'a', [1, 2]: 'b', [2, 1]: 'c', [2, 2]: 'd'}
Traceback (most recent call last):
  File "<pyshell#20>", line 1, in <module>
    d = {[1, 1]: 'a', [1, 2]: 'b', [2, 1]: 'c', [2, 2]: 'd'}
TypeError: unhashable type: 'list'

Техническое примечание. Почему в сообщении об ошибке написано «unhashable»?

Технически не совсем правильно говорить, что объект должен быть неизменным, чтобы его можно было использовать в качестве словарного ключа. Точнее, объект должен быть хешируемым, что означает, что его можно передать хеш-функции. Хэш-функция принимает данные произвольного размера и сопоставляет их с относительно более простым значением фиксированного размера, называемым хеш-значением (или просто хешем), которое используется для поиска и сравнения в таблице.

Встроенная функция Python hash() возвращает хеш-значение для объекта, который можно хэшировать, и вызывает исключение для объекта, который не является:

>>> hash('foo')
11132615637596761

>>> hash([1, 2, 3])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Все встроенные неизменяемые типы, о которых вы уже узнали, являются хешируемыми, а изменяемые типы контейнеров (списки и словари) – нет. Итак, для настоящих целей вы можете думать о хэшируемом и неизменяемом как о более или менее синонимах.

В будущих уроках вы встретите изменяемые объекты, которые также могут быть хешированы.


Ограничения на значения словаря

Напротив, нет ограничений на значения словаря. Буквально совсем нет. Значением словаря может быть любой тип объекта, поддерживаемый Python, включая изменяемые типы, такие как списки и словари, а также определяемые пользователем объекты, о которых вы узнаете в следующих руководствах.

Также нет ограничений на то, чтобы определенное значение появлялось в словаре несколько раз:

>>> d = {0: 'a', 1: 'a', 2: 'a', 3: 'a'}
>>> d
{0: 'a', 1: 'a', 2: 'a', 3: 'a'}
>>> d[0] == d[1] == d[2]
True

Операторы и встроенные функции

Вы уже познакомились со многими операторами и встроенными функциями, которые можно использовать со строками, списками и кортежами. Некоторые из них также работают со словарями.

Например, операторы in и not in возвращают True или False в зависимости от того, встречается ли указанный операнд как ключ в словаре:

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Twins',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners'
... }

>>> 'Milwaukee' in MLB_team
True
>>> 'Toronto' in MLB_team
False
>>> 'Toronto' not in MLB_team
True

Вы можете использовать оператор in вместе с оценкой короткого замыкания, чтобы избежать появления ошибки при попытке доступа к ключу, которого нет в словаре:

>>> MLB_team['Toronto']
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    MLB_team['Toronto']
KeyError: 'Toronto'

>>> 'Toronto' in MLB_team and MLB_team['Toronto']
False

Во втором случае из-за оценки короткого замыкания выражение MLB_team['Toronto'] не оценивается, поэтому исключение KeyError не возникает.

Функция len() возвращает количество пар ключ-значение в словаре:

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Twins',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners'
... }
>>> len(MLB_team)
5

Встроенные словарные методы

Как и в случае со строками и списками, есть несколько встроенных методов, которые можно вызывать в словарях. Фактически, в некоторых случаях методы списка и словаря имеют одно и то же имя. (При обсуждении объектно-ориентированного программирования вы увидите, что для разных типов вполне приемлемо иметь методы с одинаковыми именами.)

Ниже приводится обзор методов, применимых к словарям:

d.clear()

Очищает словарь.

d.clear() очищает словарь d от всех пар ключ-значение:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

>>> d.clear()
>>> d
{}

d.get(<key>[, <default>])

Возвращает значение ключа, если он существует в словаре.

Метод Python dictionary .get() предоставляет удобный способ получения значения ключа из словаря без предварительной проверки существования ключа и без возникновения ошибки.

d.get(<key>) ищет в словаре d <key> и возвращает связанное значение, если оно найдено. Если <key> не найден, возвращается None:

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> print(d.get('b'))
20
>>> print(d.get('z'))
None

Если <key> не найден и указан необязательный аргумент <default>, вместо None возвращается это значение:

>>> print(d.get('z', -1))
-1

d.items()

Возвращает список пар ключ-значение в словаре.

d.items() возвращает список кортежей, содержащих пары ключ-значение в d. Первый элемент в каждом кортеже – это ключ, а второй элемент – значение ключа:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

>>> list(d.items())
[('a', 10), ('b', 20), ('c', 30)]
>>> list(d.items())[1][0]
'b'
>>> list(d.items())[1][1]
20

d.keys()

Возвращает список ключей в словаре.

d.keys() возвращает список всех ключей в d:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

>>> list(d.keys())
['a', 'b', 'c']

d.values()

Возвращает список значений в словаре.

d.values() возвращает список всех значений в d:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

>>> list(d.values())
[10, 20, 30]

Любые повторяющиеся значения в d будут возвращаться столько раз, сколько они встречаются:

>>> d = {'a': 10, 'b': 10, 'c': 10}
>>> d
{'a': 10, 'b': 10, 'c': 10}

>>> list(d.values())
[10, 10, 10]

Техническое примечание: методы .items(), .keys() и .values() на самом деле возвращают нечто, называемое объектом представления. Объект представления словаря более или менее похож на окно с ключами и значениями. Для практических целей эти методы можно рассматривать как возвращающие списки ключей и значений словаря.

d.pop(<key>[, <default>])

Удаляет ключ из словаря, если он присутствует, и возвращает его значение.

Если <key> присутствует в d, d.pop (<key>) удаляет <key> и возвращает связанное с ним значение:

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> d.pop('b')
20
>>> d
{'a': 10, 'c': 30}

d.pop(<key>) вызывает исключение KeyError, если <key> не находится в d:

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> d.pop('z')
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    d.pop('z')
KeyError: 'z'

Если <key> не находится в d, и указан необязательный аргумент <по умолчанию>, то возвращается это значение, и исключение не возникает:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d.pop('z', -1)
-1
>>> d
{'a': 10, 'b': 20, 'c': 30}

d.popitem()

Удаляет пару ключ-значение из словаря

d.popitem() удаляет последнюю пару ключ-значение, добавленную из d, и возвращает ее как кортеж:

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> d.popitem()
('c', 30)
>>> d
{'a': 10, 'b': 20}

>>> d.popitem()
('b', 20)
>>> d
{'a': 10}

Если в d пусто, d.popitem() вызывает исключение KeyError:

>>> d = {}
>>> d.popitem()
Traceback (most recent call last):
  File "<pyshell#11>", line 1, in <module>
    d.popitem()
KeyError: 'popitem(): dictionary is empty'

Примечание. В версиях Python менее 3.6 popitem () будет возвращать произвольную (случайную) пару ключ-значение, поскольку словари Python были неупорядоченными до версии 3.6.

d.update(<obj>)

Объединяет словарь с другим словарем или с итерацией пар ключ-значение.

Если <obj> – словарь, d.update(<obj>) объединяет записи из <obj> в d. Для каждого ключа в <obj>:

  • Если ключ отсутствует в d, пара ключ-значение из <obj> добавляется к d.
  • Если ключ уже присутствует в d, соответствующее значение в d для этого ключа обновляется до значения из <obj>.

Вот пример объединения двух словарей:

>>> d1 = {'a': 10, 'b': 20, 'c': 30}
>>> d2 = {'b': 200, 'd': 400}

>>> d1.update(d2)
>>> d1
{'a': 10, 'b': 200, 'c': 30, 'd': 400}

В этом примере ключ ‘b’ уже существует в d1, поэтому его значение обновляется до 200, значение для этого ключа из d2. Однако в d1 нет ключа ‘d’, поэтому эта пара “ключ-значение” добавляется из d2.

<obj> также может быть последовательностью пар ключ-значение, подобно тому, как функция dict() используется для определения словаря. Например, <obj> можно указать как список кортежей:

>>> d1 = {'a': 10, 'b': 20, 'c': 30}
>>> d1.update([('b', 200), ('d', 400)])
>>> d1
{'a': 10, 'b': 200, 'c': 30, 'd': 400}

Или значения для объединения можно указать в виде списка аргументов ключевого слова:

>>> d1 = {'a': 10, 'b': 20, 'c': 30}
>>> d1.update(b=200, d=400)
>>> d1
{'a': 10, 'b': 200, 'c': 30, 'd': 400}

Вывод

В этом руководстве вы рассмотрели основные свойства словаря Python и узнали, как получить доступ к данным словаря и управлять ими.

Списки и словари – два наиболее часто используемых типа Python. Как вы видели, они имеют несколько общих черт, но отличаются способом доступа к их элементам. Доступ к элементам списков осуществляется по числовому индексу в зависимости от порядка, а к элементам словаря – по ключу

Из-за этой разницы списки и словари подходят для разных ситуаций. Теперь вы должны хорошо почувствовать, что лучше всего подходит для данной ситуации.


Совершенствуй знания каждый день у нас в Телеграм-каналах

Вопросы, реклама — VK | Telegram

добавление элементов и сортировка, объединение и поиск

Словарем в языке программирования Python называется неупорядоченный набор данных произвольного типа с доступом по ключу. Элементами такой коллекции выступают пары объектов, каждая из которых включает в себя ключ и значение. Для работы со словарями доступны функции, меняющие их содержимое и выполняющие различные операции над ними. Его можно конвертировать в другие типы данных, например, в строку.

Создание

Перед тем как начать работу со словарем, его нужно создать. Сделать это можно базовыми средствами языка, присвоив свободной переменной произвольное количество пар объектов. Элементы необходимо поместить в фигурные скобки, а между ключом и значением должен стоять символ двоеточия. Следующий пример демонстрирует создание словаря под именем a, который включает в себя ключи в виде чисел и значения в виде строк.

a = {1: "one", 2: "two", 3: "three"}
print(a)

{1: 'one', 2: 'two', 3: 'three'}

Вывести содержимое словаря можно стандартной функцией print, указав для нее в качестве аргумента нужный набор данных. Для заполнения словаря также используется метод dict, получающий произвольное количество пар ключей и значений. В таком случае быть ключом может только строка, как это показано в следующем примере кода.

a = dict(one = 1, two = 2, three = 3)
print(a)

{'one': 1, 'two': 2, 'three': 3}

Как и в прошлый раз, функция print отображает содержимое словаря a. В данном случае имеется пары объектов, представленных также в виде чисел и строк.

Добавление элемента

В Python 3 содержимое словаря можно в любой момент изменить по своему усмотрению. К примеру, для того чтобы внести в коллекцию новую пару объектов необходимо всего лишь указать новый ключ в квадратных скобках, а также соответствующее ему значение.

a = {1: "one", 2: "two", 3: "three"}
a[4] = "four"
print(a)

{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

В приведенном выше коде применяется оператор присваивания, благодаря чему новая пара (4 : “four”) помещается в конец уже созданной ранее коллекции a.

Объединение словарей

В том случае, если возникла необходимость в перемещении данных из одного словаря в другой, стоит воспользоваться функцией объединения update. Вызвать ее нужно на объекте, который предполагается расширить новыми парами ключей и значений. Вот пример как в Python добавить в словарь словарь:

a = {1: "one", 2: "two", 3: "three"}
b = {4: "four", 5: "five"}
a.update(b)
print(a)

{1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}

Результатом работы метода print станет вывод на экран обновленного содержимого словаря под названием a.

После объединения, новые элементы были автоматически записаны в конец коллекции.

Удаление элемента

Если словарь содержит лишнюю информацию, от нее можно легко избавиться при помощи специальной операции del. Для ее выполнения необходимо указать имя коллекции, а также ключ в квадратных скобках. Следующий пример показывает удаление пары.

a = {1: "one", 2: "two", 3: "three"}
del a[3]
print(a)

{1: 'one', 2: 'two'}

Так как операция получила ключ 3, в результате ее работы удалилось и значение three.

Получение размера

Функция len позволяет в любой момент определить текущее количество элементов словаря, если передать ей в качестве аргумента имя коллекции. В приведенном ниже примере метод print осуществляет вывод на экран размерность словаря a.

a = {1: "one", 2: "two", 3: "three"}
print(len(a))

3

Стоит заметить, что функция len возвращает точное количество пар, но не объектов. В этом случае имеется словарь, который содержит в себе ровно 3 пары.

Перебор словаря

Произвести перебор элементов словаря можно несколькими способами, в зависимости от желаемой для получения информации о его содержимом.

Перебор элементов можно осуществить с целью получения для последующей обработки:

  • Пар ключ-значение;
  • Перебор всех ключей;
  • Перебор значений.

В данном примере показывается как вывести на экран все пары этой коллекции в формате ключ : значение. Для этого используется цикл for и функция items, работающая с элементами словаря.

a = {1: "one", 2: "two", 3: "three"}
for key, value in a.items():
    print(key, ":", value)

1 : one
2 : two
3 : three

Чтобы получить только ключи, следует применить метод keys, вызывав его на словаре.

a = {1: "one", 2: "two", 3: "three"}
for key in a.keys():
    print(key)

1
2
3

Аналогичным образом нужно поступить, чтобы вывести только значения словаря. Однако в таком случае в цикле for используется метод values.

a = {1: "one", 2: "two", 3: "three"}
for val in a.values():
    print(val)

one
two
three

В обоих случаях отображается только выбранная часть пары, ключ или значение.

Поиск

Проверить наличие определенного ключа можно при помощи операции in. Для этого достаточно вывести результат ее выполнения для словаря по имени a.

a = {1: "one", 2: "two", 3: "three"}
print(2 in a)
print(4 in a)

True
False

Как можно заметить, проверка ключа 2 дала положительный результат (True). Во втором случае вывелось значение False, поскольку ключа 4 в словаре не обнаружено.

Сортировка

Средства языка дают возможность проводить в Python сортировку словаря по ключам и значениям, в зависимости от необходимости. В следующем примере имеется коллекция данных по имени a, в которой содержится информация в произвольном порядке. Ключами здесь выступают числа, а значениями являются строки. Сортировка осуществляется за счет импортированного модуля operator и встроенного метода itemgetter, получающего 0 или 1.

import operator
a = {2 : "two", 3 : "three", 1 : "one"}
b = sorted(a.items(), key = operator.itemgetter(0))
print(b)
b = sorted(a.items(), key = operator.itemgetter(1))
print(b)

[(1, 'one'), (2, 'two'), (3, 'three')]
[(1, 'one'), (3, 'three'), (2, 'two')]

Как можно заметить, аргумент 0 позволяет отсортировать словарь по ключу, в то время как 1 дает возможность вывести его содержимое в алфавитном порядке значений.

Сравнение

Иногда нужно удостовериться, что два словаря содержат абсолютно одинаковые данные, либо узнать какая коллекция больше или меньше по размеру. В этом случае на помощь приходит метод cmp, получающий в качестве параметров два словаря.

a = {1: "one", 2: "two", 3: "three"}
b = {4: "four", 5: "five"}
c = {1: "one", 2: "two", 3: "three"}
print(cmp(a, b))
print(cmp(b, c))
print(cmp(a, c))

1
-1
0

Приведенный код продемонстрировал выполнение метода cmp с трема комбинациями аргументов. Как видно из результатов выдачи, функция возвращает 1, если первый больше второго, -1, если наоборот и 0, когда данные полностью идентичны.

Копирование

Метод copy используется для копирования содержимого одного словаря в другой. Данный пример демонстрирует перенос ключей и значений из коллекции a в b.

a = {1: "one", 2: "two", 3: "three"}
b = a.copy()
print(b)

{1: 'one', 2: 'two', 3: 'three'}

Как можно заметить, порядок и содержимое всех пар было сохранено в новом наборе.

Очистка

Чтобы избавиться от всех элементов словаря, стоит вызвать для него функцию clear.

a = {1: "one", 2: "two", 3: "three"}
a.clear()
print(a)

{}

В результате получается абсолютно пустой набор данных.

Генератор словарей

Как и с другими наборами данных, производить заполнение словарей можно при помощи генераторов. В следующем примере демонстрируется создание числовых пар коллекции с использованием генератора словарей Python с методом range, получающего в качестве аргумента 5.

a = {a: a * a for a in range(5)}
print(a)

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Таким образом, на выходе получается словарь a, включающий в себя ровно 5 пар. Ключами являются числа от 0 до 4, а значениями выступают их математические квадраты.

Конвертация в строку

Словарь можно очень легко преобразовать в строку для более удобной работы с цельным представлением его содержимого. Чтобы сделать это, потребуется функция str. Как можно видеть из результатов выполнения метода type, конвертация прошла успешно.

a = {1: "one", 2: "two", 3: "three"}
b = str(a)
print(b)
print(type(b))

{1: 'one', 2: 'two', 3: 'three'}
<class 'str'>

Аналогичным образом происходит обратное преобразование строки Python в словарь. Важно, чтобы ее текстовое содержимое подходило по структуре под рассматриваемую коллекцию.

a = '{1: "one", 2: "two", 3: "three"}'
b = eval(a)
print(b)
print(type(b))

{1: 'one', 2: 'two', 3: 'three'}
<class 'dict'>

Как видно из примера, метод eval конвертирует весь текст строки в новый словарь.

Вложенные

В Python словари могут быть вложенными, то есть выступать частью другого более крупного словаря. При помощи уже знакомых ранее фигурных скобок и двоеточий можно обозначить границы этого набора данных и указать программе пары ключей со значениями.

a = {
    "First": {
        1: "one",
        2: "two",
        3: "three"
    },
    "Second": {
        4: "four",
        5: "five"
    }
}
print(a)

{'First': {1: 'one', 2: 'two', 3: 'three'}, 'Second': {4: 'four', 5: 'five'}}

В примере, описанном выше, создается словарь a, включающий в себя два других словаря (First и Second). Те, в свою очередь, содержат несколько пар ключей и значений.

Резюме

Следующая таблица демонстрирует краткую сводку по всем рассмотренным методам для работы со словарями в Python 3. В таблице отображаются названия методов, а также информация о  их назначении.

Название Назначение
update Объединение содержимого двух словарей в один
len Получение размера
items Возвращает пары (ключи и значения)
keys Возвращает ключи
values Возвращает значения
copy Копирует содержимое в другой словарь
clear Полная очистка всех элементов
eval Конвертация строки в словарь

Словари в Python — Программирование с нуля

Из этой статьи вы узнаете все о словарях в языке программирования Python; как они создаются, доступ к элементам, добавление и удаление элементов, а также различные встроенные методы Python.

Что такое словарь в Python?

Словарь Python представляет собой неупорядоченную коллекцию элементов. В то время как другие составные типы данных имеют только значение как элемент, словарь имеет пару ключ:значение.

Словари оптимизированы для получения значений, когда ключ известен.

Как создать словарь?

Создать словарь очень просто, нужно поместить элементы в виде пар ключ:значение в фигурные скобки {}, разделяя их запятой.

Каждый элемент словаря имеет ключ и соответствующее значение.

Хотя значения могут быть любого типа данных и могут повторяться, ключи должны быть неизменного типа (строка, число или кортеж с неизменяемыми элементами) и должны быть уникальными для этого словаря.

# пустой словарь
my_dict = {}
# словарь с ключами типа integer (число)
my_dict = {1: 'apple', 2: 'ball'}
# словарь с со смешенным типом ключей
my_dict = {'name': 'John', 1: [2, 4, 3]}
# создание словаря при помощи dict()
my_dict = dict({1:'apple', 2:'ball'})

Как вы можете видеть выше, мы также можем создать словарь, используя встроенную функцию dict().

Как получить доступ к элементам из словаря?

В то время как индексирование используется с другими типами контейнеров для доступа к значениям, словарь использует ключи. Ключ можно использовать либо в квадратных скобках, либо с помощью метода get().

Разница при использовании get() заключается в том, что он возвращает None вместо KeyError, если ключ не найден.

my_dict = {'name':'Jack', 'age': 26}

# Результат: Jack
print(my_dict['name'])

# Результат: 26
print(my_dict.get('age'))

Как изменить или добавить элементы в словарь?

Словарь — изменяемый тип данных. Мы можем добавить новые элементы или изменить значение существующих элементов, используя оператор присваивания.

Если ключ уже присутствует, значение обновляется, иначе в словарь добавляется новая пара ключ:значение.

my_dict = {'name':'Jack', 'age': 26}

# обновляем значение
my_dict['age'] = 27

# Результат: {'age': 27, 'name': 'Jack'}
print(my_dict)

# добавляем элемент
my_dict['address'] = 'Downtown'

# Результат: {'address': 'Downtown', 'age': 27, 'name': 'Jack'}
print(my_dict)

Как удалить элементы из словаря Python?

Мы можем удалить определенный элемент в словаре, используя метод pop(). Этот метод удаляет элемент с предоставленным ключом и возвращает значение.

Метод popitem() может использоваться для удаления и возврата произвольного элемента (ключ, значение) из словаря. Все элементы сразу можно удалить, используя метод clear().

Мы также можем использовать ключевое слово del для удаления отдельных элементов или всего словаря.

# создаем словарь
squares = {1:1, 2:4, 3:9, 4:16, 5:25}

# удалить определенный элемент словаря
# результат: 16
print(squares.pop(4))

# результат: {1: 1, 2: 4, 3: 9, 5: 25}
print(squares)

# удалить случайный элемент из словаря
# результат: (1, 1)
print(squares.popitem())

# результат: {2: 4, 3: 9, 5: 25}
print(squares)

# удалить определенный элемент словаря
del squares[5]

# результат: {2: 4, 3: 9}
print(squares)

# удалить все из словаря
squares.clear()

# результат: {}
print(squares)

# удалить словарь
del squares

# выведет ошибку
# print(squares)

Методы словарей Python

Методы, доступные для использования со словарем, приведены в таблице ниже. Некоторые из них уже были использованы в приведенных выше примерах.

  • clear() — Удалить все элементы из словаря.
  • copy() — Возвращает копию словаря.
  • fromkeys(seq [, v]) — Возвращает новый словарь с ключами от seq и значением, равным v (по умолчанию None).
  • get(key [, d]) — Возвращает значение ключа. Если ключ не существует, возвращает d (по умолчанию None).
  • items() — Возвращает новый вид элементов словаря (ключ, значение).
  • keys() — Возвращает новый вид ключей словаря.
  • pop(key [, d]) — Удалить элемент с ключом и вернуть его значение или d, если ключ не найден. Если d не указано и ключ не найден, выдается KeyError.
  • popitem() — Удалить и вернуть произвольный элемент (ключ, значение). Вызывает KeyError, если словарь пуст.
  • setdefault(ключ [, d]) — Если ключ находится в словаре, вернуть его значение. Если нет, введите ключ со значением d и верните d (по умолчанию None).
  • update([другое]) — Обновить словарь парами ключ / значение из других, перезаписывая существующие ключи.
  • values() — Возвращает новое представление значений словаря

Вот несколько примеров использования этих методов.

marks = {}.fromkeys(['Math','English','Science'], 0)

# результат: {'English': 0, 'Math': 0, 'Science': 0}
print(marks)

for item in marks.items():
print(item)

# результат: ['English', 'Math', 'Science']
list(sorted(marks.keys()))

Генератор словаря Python

Генератор словаря — это элегантный и лаконичный способ создания нового словаря из итерируемых объектов в Python.

Генерация словаря состоит из пары выражений (ключ: значение), за которой следует инструкция внутри фигурных скобок {}.

Вот пример создания словаря, в котором каждый элемент является парой числа и его квадрата.

squares = {x: x*x for x in range(6)}

# Результат: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
print(squares)

Другие операции со словарями в Python

Проверка на на наличие элемента в словаре

Мы можем проверить, находится ли ключ в словаре или нет, используя ключевое слово in. Обратите внимание, что тест на наличие элемента предназначен только для ключей, а не для значений.

squares = {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

# результат: True
print(1 in squares)

# результат: True
print(2 not in squares)

# проверка работает только для ключей, а не для значений
# результат: False
print(49 in squares)

Перебор элементов словаря

Используя цикл for, мы можем перебирать элементы в словаре.

squares = {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}
for i in squares:
    print(squares[i])

Встроенные функции и словари

Встроенные функции, такие как all(), any(), len(), cmp(), sorted() и т.д., обычно используются со словарем для выполнения различных задач.

  • all() — Возвращает True, если все ключи словаря истинны (или если словарь пуст).
  • any() — Возвращает True, если любой ключ словаря равен true. Если словарь пуст, вернет False.
  • len() — Возвращает длину (количество элементов) в словаре.
  • cmp() — Сравнивает элементы двух словарей.
  • sorted() — Возвращает новый отсортированный список ключей в словаре.

Вот несколько примеров, которые используют встроенные функции Python для работы со словарем.

squares = {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

# результат: 5
print(len(squares))

# результат: [1, 3, 5, 7, 9]
print(sorted(squares))

Как устроены словари в Python

Автор: PythonInDepth

Представьте себе огромную библиотеку, в которой вы хотите найти «Пикник на обочине». Как это сделать?

Наивный способ — перебирать. Взять первую книгу, понять, что это не Стругацкие, поставить обратно, взять следующую, … и так далее. В лучшем случае «Пикник на обочине» окажется в первой ячейке и мы справимся за один ход. В худшем придется перебрать все n книг библиотеки, за за O(n) шагов. Но можно быстрее.

Для этого определим функцию, которая получает название книги и возвращает число. Такая функция-справочник:

«Пикник на обочине» -> 1
«Декамерон» -> 2
«Уловка 22» -> 3

Положим «Пикник на обочине» на первую полку, «Декамерон» на вторую, и так далее. Когда нам понадобится книга, мы отправим название в эту функцию и сразу получим номер ячейки. Теперь книгу можно найти всего за два шага:

  1. вычислить номер книги по названию,
  2. найти ее на полке с этим номером.

Получается сложность O(1), и это очень быстро! Положить книгу на свое место тоже можно за фиксированное число шагов, вне зависимости от размера библиотеки. Побочным эффектом такого подхода будет то, что в библиотеке не будет дубликатов книг, ведь все копии «Декамерона» будут попадать в ячейку с одним и тем же адресом.

Функция, которая ставит объекту в соответствие число, называется хеш-функцией. Любая хеш-функция должна удовлетворять требованию:

Если два объекта идентичны, то их хеши равны.

Идеальная хеш-функция должна удовлетворять еще одному требованию:

Если у двух объектов одинаковый хеш, то это одинаковые объекты.

На практике даже хорошую хеш-функцию написать сложно. Поэтому иногда бывает так, что хеш-функция возвращает два одинаковых числа для разных входных данных. Например, если хеш-функция вернула

«Облачный атлас» -> 10
«Москва-Петушки» -> 10

то это значит, что мы должны поставить две разные книги на одну полку. И когда мы приходим за книгой с номером 10, становится непонятно, какую из книг выбрать.

Какое отношение эта проблема имеет к Python? Дело в том, что множества и словари в Python реализованы как хеш-таблицы, — то есть, ровно такие библиотеки с книгами на полках. Когда вы помещаете пару ключ-значение в словарь, интерпретатор вычисляет хеш ключа и кладет значение в ячейку памяти с адресом, совпадающим с результатом работы хеш-функции.

И если вдруг оказывается, что «Облачный атлас» и «Москва-Петушки» нужно положить в одну и ту же ячейку, то такую ситуацию называют коллизией.

Способов бороться с хеш-коллизиями концептуально два.

1. Метод цепочки

В этом методе каждая ячейка массива — это указатель на связный список пар ключ-значение, соответствующих одному и тому же хеш-значению ключа. Коллизии просто приводят к тому, что появляются цепочки длиной больше одного элемента.

Это как если положить все книги с одинаковым номером на одну полку. Тогда при поиске книги придется найти нужную полку, взять первую книгу и прочитать название. Если не та — проверить следующую, и так далее. В худшем случае все n книг попадут на одну полку и сложность получится O(n).

2. Открытая адресация

В этом случае в ячейки помещаются не указатели на списки, а сами пары ключ-значение. Алгоритм такой: вычисляем хеш-функцию, проверяем нужную ячейку. Если искомого элемента нет, то ищем в следующей ячейке. Следующую ячейку выбирают разными методами: это может быть просто фиксированный интервал до следующей ячейки, повторное хеширование вспомогательной хеш-функцией или другие методы.

Говоря языком библиотекаря, в этом случае библиотека получается большая, но полупустая. Потому что если полка, на которую вы хотели положить книгу, оказалась занята, вы выбираете другую свободную полку и кладете книгу туда. А потом по такому же алгоритму вычисляете, где находится нужная книга.

В Python множествах и словарях используется метод открытой адресации.

Какие из всего этого выводы?

  • Ключи словаря должны быть хешируемыми.
  • Словари неэффективны по памяти. Если экономите память, используйте кортежи.
  • Поиск по ключу в итоге не O(1), но все равно очень быстрый.
  • Модифицировать словарь, по которому итерируешься, — плохая идея. Интерпретатор может решить, что пора ресайзить хеш-таблицу, и тогда старые данные переедут в новую табличку. Не стоит.

И все то же самое применимо к множествам, потому что они реализованы похожим образом.

  • А ещё становится понятно, что множества работают сильно быстрее списоков.

Словари Python


Словарь

Словарь — это неупорядоченный, изменяемый и индексируемый набор. В Python словари записываются в фигурные скобки, а
у них есть ключи и ценности.

Пример

Создать и распечатать словарь:

thisdict = {
«марка»: «Ford»,
«модель»: «Мустанг»,
«год»: 1964
}
печать (thisdict)

Попробуй сам »


Доступ к элементам

Вы можете получить доступ к элементам словаря, указав его ключевое имя внутри
квадратные скобки:

Существует также метод get () , который даст вам тот же результат:



Изменить значения

Вы можете изменить значение определенного элемента, указав его ключевое имя:

Пример

Измените «год» на 2018:

thisdict = {
«марка»: «Ford»,
«модель»: «Мустанг»,
«год»: 1964
}
thisdict [«год»] = 2018

Попробуй сам »


Просмотр словаря

Вы можете просматривать словарь в цикле, используя
для петли .

При циклическом просмотре словаря возвращаемое значение — это ключей из
словарь, но есть методы для возврата значений .

Пример

Распечатать все имена ключей в словаре, одно за другим:

для x в thisdict:
print (x)

Попробуй сам »

Пример

Распечатать все значения в словаре, одно за другим:

для x в thisdict:
print (thisdict [x])

Попробуй сам »

Пример

Вы также можете использовать метод values ​​() для
возвращаемые значения словаря:

для x в thisdict.значения ():
печать (x)

Попробуй сам »

Пример

Перебрать оба ключа и значения , используя
элементов () метод:

для x, y в thisdict.items ():
print (x, y)

Попробуй сам »


Проверить, существует ли ключ

Чтобы определить, присутствует ли указанный ключ в словаре, используйте ключевое слово в :

Пример

Проверить, присутствует ли «модель» в словаре:

thisdict = {
«марка»: «Ford»,
«модель»: «Мустанг»,
«год»: 1964
}
если «модель» в этом диктате:
print («Да,» модель »
один из ключей в словаре thisdict «)

Попробуй сам »


Длина словаря

Чтобы определить, сколько элементов (пар ключ-значение) имеет словарь, используйте функцию len ()
функция.

Пример

Вывести количество пунктов в словаре:

print (len (thisdict))

Попробуй сам »


Добавление элементов

Добавление элемента в словарь выполняется с помощью нового ключа индекса и присвоения ему значения:

Пример

thisdict = {
«марка»: «Ford»,
«модель»: «Мустанг»,
«год»: 1964
}
thisdict [«color»] = «красный»
печать (thisdict)

Попробуй сам »


Удаление элементов

Есть несколько способов удалить элементы из словаря:

Пример

Метод pop () удаляет элемент с указанным именем ключа:

thisdict = {
«марка»: «Ford»,
«модель»: «Мустанг»,
«год»: 1964
}
thisdict.поп («модель»)
печать (thisdict)

Попробуй сам »

Пример

Метод popitem () удаляет последний
вставленный элемент (в версиях до 3.7 вместо этого удаляется случайный элемент):

thisdict = {
«марка»: «Ford»,
«модель»: «Мустанг»,
«год»: 1964
}
thisdict.poITEm ()
печать (thisdict)

Попробуй сам »

Пример

Ключевое слово del удаляет элемент с указанным
имя ключа:

thisdict = {
«марка»: «Ford»,
«модель»: «Мустанг»,
«год»: 1964
}
del thisdict [«модель»]
print (thisdict)

Попробуй сам »

Пример

Ключевое слово del может также удалить
словарь полностью:

thisdict = {
«марка»: «Ford»,
«модель»: «Мустанг»,
«год»: 1964
}
del thisdict
print (thisdict) # это вызовет ошибку, потому что «thisdict»
более не существует.

Попробуй сам »

Пример

Метод clear () очищает
словарь:

thisdict = {
«марка»: «Ford»,
«модель»: «Мустанг»,
«год»: 1964
}
thisdict.clear ()
print (thisdict)

Попробуй сам »


Копировать словарь

Вы не можете скопировать словарь, просто набрав dict2 =
dict1
, потому что: dict2 будет только
ссылка
на dict1 , и изменения, внесенные в
dict1 также будет автоматически выполнен в
dict2 .

Есть способы сделать копию, один из них — использовать встроенный Словарь
метод
Копия ()
.

Пример

Сделайте копию словаря с помощью метода copy () :

thisdict = {
«марка»: «Ford»,
«модель»: «Мустанг»,
«год»: 1964
}
mydict
= thisdict.copy ()
печать (mydict)

Попробуй сам »

Еще один способ сделать копию — использовать встроенную функцию
dict () .

Пример

Сделайте копию словаря с помощью dict ()
функция:

thisdict = {
«марка»: «Ford»,
«модель»: «Мустанг»,
«год»: 1964
}
mydict
= dict (thisdict)
печать (mydict)

Попробуй сам »


Вложенные словари

Словарь может также содержать много словарей, это называется вложенным.
словари.

Пример

Создайте словарь, содержащий три словаря:

myfamily = {
«child1»: {
«name»: «Эмиль»,
«год»: 2004
},
«ребенок2»: {
«имя»: «Тобиас»,
«год»: 2007
},
«child3»: {
«name»: «Линус»,
«год»: 2011
}
}

Попробуй сам »

Или, если вы хотите вложить три уже существующих словаря как
словарей:

Пример

Создайте три словаря, затем создайте один словарь, который будет содержать
три других словаря:

child1 = {
«имя»: «Эмиль»,
«год»: 2004
}
child2 = {
«name»: «Tobias»,
«year»: 2007
}
child3 = {
«name»: «Linus»,
«год»: 2011
}

myfamily = {
«child1»: child1,
«ребенок2»: ребенок2,
«ребенок3»: ребенок3
}

Попробуй сам »


Конструктор dict ()

Также можно использовать конструктор dict () для создания
новый словарь:

Пример

thisdict = dict (марка = «Ford», модель = «Mustang», год = 1964)
# обратите внимание, что ключевые слова не являются строковыми литералами
# обратите внимание на использование равенства вместо двоеточия в присвоении
печать (thisdict)

Попробуй сам »


Методы словаря

Python имеет набор встроенных методов, которые можно использовать в словарях.

Метод Описание
clear () Удаляет все элементы из словаря
copy () Возвращает копию словаря
fromkeys () Возвращает словарь с указанными ключами и значением
get () Возвращает значение указанного ключа
items () Возвращает список, содержащий кортеж для каждой пары значений ключа
keys () Возвращает список, содержащий ключи словаря
pop () Удаляет элемент с указанным ключом
popitem () Удаляет последний
вставленная пара «ключ-значение»
setdefault () Возвращает значение указанного ключа.Если ключ не существует: вставьте ключ с указанным значением
update () Обновляет словарь с указанными парами ключ-значение
values ​​() Возвращает список всех значений в словаре


.

Словарь Python (с примерами)

Словарь Python — это неупорядоченный набор элементов. Каждый элемент словаря имеет пару ключ / значение .

Словари оптимизированы для извлечения значений, когда ключ известен.


Создание словаря Python

Создать словарь так же просто, как поместить элементы в фигурные скобки {} , разделенные запятыми.

Элемент имеет ключ и соответствующее значение , которое выражается в виде пары (ключ : значение ).

Хотя значения могут относиться к любому типу данных и повторяться, ключи должны иметь неизменяемый тип (строка, число или кортеж с неизменяемыми элементами) и должны быть уникальными.

  # пустой словарь
my_dict = {}

# словарь с целочисленными ключами
my_dict = {1: 'яблоко', 2: 'мяч'}

# словарь со смешанными ключами
my_dict = {'имя': 'Джон', 1: [2, 4, 3]}

# используя dict ()
my_dict = dict ({1: 'яблоко', 2: 'мяч'})

# из последовательности, содержащей каждый элемент как пару
my_dict = dict ([(1, 'яблоко'), (2, 'мяч')])  

Как видно из вышеизложенного, мы также можем создать словарь, используя встроенную функцию dict () .


Доступ к элементам из словаря

В то время как индексирование используется с другими типами данных для доступа к значениям, словарь использует ключей . Ключи могут использоваться либо внутри квадратных скобок [] , либо с методом get () .

Если мы используем квадратные скобки [] , KeyError возникает в случае, если ключ не найден в словаре. С другой стороны, метод get () возвращает None , если ключ не найден.

  # get vs [] для получения элементов
my_dict = {'name': 'Джек', 'возраст': 26}

# Выход: Джек
print (my_dict ['имя'])

# Вывод: 26
print (my_dict.get ('возраст'))

# Попытка получить доступ к несуществующим ключам выдает ошибку
# Выход Нет
print (my_dict.get ('адрес'))

# KeyError
print (my_dict ['адрес'])  

Выход

  Джек
26
Никто
Отслеживание (последний вызов последний):
  Файл «<строка>», строка 15, в <модуле>
    print (my_dict ['адрес'])
KeyError: 'адрес'  

Изменение и добавление элементов словаря

Словари изменяемы.Мы можем добавлять новые элементы или изменять значение существующих элементов с помощью оператора присваивания.

Если ключ уже существует, то существующее значение обновляется. Если ключ отсутствует, в словарь добавляется новая пара (ключ : значение ).

  # Изменение и добавление элементов словаря
my_dict = {'name': 'Джек', 'возраст': 26}

# обновить значение
my_dict ['age'] = 27

#Output: {'age': 27, 'name': 'Джек'}
печать (my_dict)

# Добавьте предмет
my_dict ['address'] = 'Центр города'

# Вывод: {'адрес': 'Центр города', 'возраст': 27, 'имя': 'Джек'}
печать (my_dict)  

Выход

  {'name': 'Jack', 'age': 27}
{'name': 'Jack', 'age': 27, 'address': 'Downtown'}  

Удаление элементов из словаря

Мы можем удалить конкретный элемент из словаря с помощью метода pop () .Этот метод удаляет элемент с предоставленным ключом и возвращает значение .

Метод popitem () может использоваться для удаления и возврата произвольной пары элементов (ключ, значение) из словаря. Все элементы можно удалить сразу, используя метод clear () .

Мы также можем использовать ключевое слово del для удаления отдельных элементов или всего словаря.

  # Удаление элементов из словаря

# создать словарь
квадраты = {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# удалить конкретный элемент, возвращает его значение
# Вывод: 16
печать (квадраты.поп (4))

# Вывод: {1: 1, 2: 4, 3: 9, 5: 25}
печать (квадраты)

# удалить произвольный элемент, вернуть (ключ, значение)
# Вывод: (5, 25)
печать (квадраты. попьем ())

# Вывод: {1: 1, 2: 4, 3: 9}
печать (квадраты)

# удалить все элементы
squares.clear ()

# Выход: {}
печать (квадраты)

# удаляем сам словарь
дель квадратов

# Выдает ошибку
печать (квадраты)  

Выход

  16
{1: 1, 2: 4, 3: 9, 5: 25}
(5, 25)
{1: 1, 2: 4, 3: 9}
{}
Отслеживание (последний вызов последний):
  Файл «<строка>», строка 30, в <модуле>
    печать (квадраты)
NameError: имя 'squares' не определено  

Методы словаря Python

Методы, доступные со словарем, представлены в таблице ниже.Некоторые из них уже использовались в приведенных выше примерах.

Метод Описание
прозрачный () Удаляет все элементы из словаря.
копия () Возвращает частичную копию словаря.
fromkeys (seq [, v]) Возвращает новый словарь с ключами из seq и значением, равным v (по умолчанию None ).
получить (ключ [, d]) Возвращает значение ключа . Если ключ не существует, возвращает d (по умолчанию Нет ).
позиции () Вернуть новый объект элементов словаря в формате (ключ, значение).
ключи () Возвращает новый объект ключей словаря.
pop (клавиша [, d]) Удаляет элемент с ключом и возвращает его значение или d , если ключ не найден.Если d не указан и ключ не найден, возникает KeyError .
попитем () Удаляет и возвращает произвольный элемент (ключ , значение ). Вызывает KeyError , если словарь пуст.
setdefault (клавиша [, d]) Возвращает соответствующее значение, если ключ находится в словаре. В противном случае вставляет ключ со значением d и возвращает d (по умолчанию Нет ).
обновление ([другое]) Обновляет словарь парами ключ / значение из других , перезаписывая существующие ключи.
значений () Возвращает новый объект значений словаря

Вот несколько примеров использования этих методов.

  # Словарные методы
mark = {} .fromkeys (['Math', 'English', 'Science'], 0)

# Вывод: {'English': 0, 'Math': 0, 'Science': 0}
печать (отметки)

за товар в знаках.Предметы():
    печать (элемент)

# Вывод: ['English', 'Math', 'Science']
print (list (sorted (marks.keys ())))  

Выход

  {'Math': 0, 'English': 0, 'Science': 0}
('Математика', 0)
('Английский', 0)
('Наука', 0)
["Английский язык", "Математика", "Наука"]  

Понимание словаря Python

Понимание словарей — это элегантный и лаконичный способ создания нового словаря из итерируемого в Python.

Понятие словаря состоит из пары выражений (ключ : значение ), за которой следует оператор для внутри фигурных скобок {} .

Вот пример создания словаря, в котором каждый элемент представляет собой пару числа и его квадрата.

  # Понимание словаря
квадраты = {x: x * x для x в диапазоне (6)}

печать (квадраты)  

Выход

  {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}  

Этот код эквивалентен

  квадрата = {}
для x в диапазоне (6):
    квадраты [x] = x * x
печать (квадраты)  

Выход

  {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}  

Понимание словаря может дополнительно содержать дополнительные операторы for или if.

Необязательный , если оператор может отфильтровать элементы для формирования нового словаря.

Вот несколько примеров создания словаря только с нечетными элементами.

  # Понимание словаря с условным условием if
odd_squares = {x: x * x для x в диапазоне (11), если x% 2 == 1}

печать (odd_squares)  

Выход

  {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}  

Чтобы узнать больше о понимании словаря, посетите Python Dictionary Computing.


Другие словарные операции

Тест на членство в словаре

Мы можем проверить, находится ли ключ в словаре или нет, используя ключевое слово в . Обратите внимание, что проверка членства предназначена только для ключей , а не для значений .

  # Тест на членство для ключей словаря
квадраты = {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

# Вывод: True
печать (1 в квадратах)

# Вывод: True
печать (2 не в квадратах)

# проверка членства только для ключа, а не для значения
# Вывод: Ложь
печать (49 в квадратах)  

Выход

  Верно
Правда
Ложь  

Итерации по словарю

Мы можем перебирать каждый ключ в словаре, используя цикл для .

  # Перебор словаря
квадраты = {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}
для i в квадратах:
    печать (квадраты [i])  

Выход

  1
9
25
49
81  

Словарь встроенных функций

Встроенные функции, такие как all () , any () , len () , cmp () , sorted () и т. Д., Обычно используются со словарями для выполнения различных задач.

Функция Описание
все () Вернуть Истина , если все ключи словаря истинны (или если словарь пуст).
любой () Вернуть Истина , если любой ключ словаря верен. Если словарь пуст, вернуть Ложь .
лён () Возвращает длину (количество элементов) в словаре.
cmp () Сравнивает элементы двух словарей. (Недоступно в Python 3)
отсортировано () Вернуть новый отсортированный список ключей в словаре.

Вот несколько примеров использования встроенных функций для работы со словарем.

  # Встроенные функции словаря
квадраты = {0: 0, 1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

# Вывод: Ложь
печать (все (квадраты))

# Вывод: True
печать (любая (квадраты))

# Вывод: 6
print (len (квадраты))

# Вывод: [0, 1, 3, 5, 7, 9]
печать (отсортировано (квадраты))  

Выход

  Ложь
Правда
6
[0, 1, 3, 5, 7, 9]  

.

Программирование python / словари — Wikilivres

Wikilivres ne Possède pas de page avec ce nom.


Soit vous avez mal écrit le titre:

  • Recherchez «Программирование python / dictionnaires» dans les autres pages (помощник), или
  • Consultez la liste de ceux dont le titre begin ainsi.

Soit la page n’existe pas enore:

  • La page a peut-être été supprimée: voir l’historique des effacements.
  • Créez la page (помощник), or demandez sa création .

.

5. Structures de données — Документация Python 3.8.6

Эта глава представляет плюс детально прорабатывает точки déjà décrits précédemment и вводит новую игру понятий.

5.1. Благодарности к списку

Le type liste dispose de méthodes Supplémentaires. Voici toutes les méthodes des objets de type liste:

список. добавить ( x )

Ajoute un élément à la fin de la liste. Эквивалент a [len (a):] = [x] .

список. расширить ( итерация )

Étend la liste en y ajoutant tous les éléments de l’itérable. Эквивалент a [len (a):] = iterable .

список. вставка ( i , x )

Insère un élément à la position indiquée. Le premier argument est la position de l’élément courant avant lequel l’insertion doit s’effectuer, donc a.insert (0, x) insère l’élément en tête de la liste et a.insert (len (a), x) эквивалентно a.append (x) .

список. удалить ( x )

Supprime de la liste le premier élément dont la valeur est égale à x . Исключение составляет ValueError , оставшееся без изменений.

список. pop ([ i ])

Enlève de la liste l’élément situ à la position indiquée et le renvoie en valeur de retour.Si aucune position n’est spécifiée, a.pop () enlève et renvoie le dernier élément de la liste (les crochets autour du i dans la signature de la méthode indiquent que ce paramètre est facultatif et non que vous devez placer вязания крючком в этом коде! Вы ретроверзаем эту нотацию в соответствии с указанием Справочника по Библиотеке Python).

список. прозрачный ()

Supprime tous les éléments de la liste.Équivalent à del a [:] .

список. индекс ( x [, начало [, конец ]])

Renvoie la position du premier élément de la liste dont la valeur égale x (en commençant à compter les position à partir de zéro). Единственное исключение: ValueError — это результат, который не может быть нарушен.

Опции аргументов начало и конец не интерпретируются в нотации траншей и не используются для ограничения поиска в конкретной последовательности.L’indice renvoyé est расчет относительно дебюта полной и не относительной последовательности в start .

список. количество ( x )

Renvoie le nombre d’éléments ayant la valeur x в списке.

список. сортировка (ключ = нет , обратный = ложь )

Ordonne les éléments dans la liste (les arguments peuvent personnaliser l’ordonnancement, voir sorted () pour leur explication).

список. обратный ()

Inverse l’ordre des éléments dans la liste.

список. копия ()

Renvoie une copie superficielle de la liste. Эквивалент a [:] .

L’exemple suivant use la plupart des méthodes des listes:

 >>> fruit = ['апельсин', 'яблоко', 'груша', 'банан', 'киви', 'яблоко', 'банан']
>>> фрукты.count ('яблоко')
2
>>> fruit.count ('мандарин')
0
>>> fruit.index ('банан')
3
>>> fruit.index ('banana', 4) # Найти следующий банан, начиная с позиции 4
6
>>> fruit.reverse ()
>>> фрукты
["банан", "яблоко", "киви", "банан", "груша", "яблоко", "апельсин"]
>>> fruit.append ('виноград')
>>> фрукты
['банан', 'яблоко', 'киви', 'банан', 'груша', 'яблоко', 'апельсин', 'виноград']
>>> fruit.sort ()
>>> фрукты
['яблоко', 'яблоко', 'банан', 'банан', 'виноград', 'киви', 'апельсин', 'груша']
>>> фрукты.поп ()
'груша'
 

Vous avez probablement remarqué que les méthodes telles que insert , remove or sort , qui ne font que modifier la liste, n’affichent pas de valeur de retour (elles renvoient None ). Это принцип уважения к структурам переменных в Python.

Une autre выбрал que vous remarquerez peut-être est que toutes les données ne peuvent pas être ordonnées ou comparees. Par example, [Нет, 'hello', 10] ne sera pas ordonné parce que les entiers ne peuvent pas être compares aux chaînes de caractères et None ne peut pas être compare à d’autres типов.En outre, il existe определенные типы qui n’ont pas de Relations d’ordre définie. Пример: 3 + 4j <5 + 7j n'est pas une compareison valide.

5.1.1. Утилизация листов свай

Les méthodes des listes rendent très easy leur utilization Com des piles, où le dernier élément ajouté est le premier récupéré («dernier entré, premier sorti» или LIFO pour last-in, first-out en anglais). Залейте элемент по ворсу, используйте метод append () .Залейте объект в мешочек с кулаком, используйте метод pop () без указания положения. Пример по номиналу:

 >>> стек = [3, 4, 5]
>>> stack.append (6)
>>> stack.append (7)
>>> стек
[3, 4, 5, 6, 7]
>>> stack.pop ()
7
>>> стек
[3, 4, 5, 6]
>>> stack.pop ()
6
>>> stack.pop ()
5
>>> стек
[3, 4]
 

5.1.2. Использование списков файлов

Возможная игра для использования в списке файлов, одна премьера для использования в качестве премьер-министра («премьер-вход, премьер-сортировка» или FIFO для в порядке очереди, в порядке очереди ); toutefois, les listes ne sont pas très efficaces pour réaliser ce type de traitement.Alors que les ajouts et suppressions en fin de liste sont rapides, les opérations d'insertions ou de retraits en début de liste sont lentes (car tous les autres éléments doivent être décalés d'une position).

Залейте имплементарный файл, используйте класс collections.deque , чтобы получить более быстрое ускорение операций и повторное использование дополнительных материалов. Пример по номиналу:

 >>> из коллекций import deque
 

.

Добавить комментарий

Ваш адрес email не будет опубликован.

2022 © Все права защищены. Карта сайта