Python создать словарь. Интерактивный учебник языка Python. Получение данных из словаря

Привет, Хаброжители! Мы пополнили новинкой свою серию O"Reilly :

Гибкий легкий код, соответствующий стандартам - его можно получить, если подойти к проблеме аналитически. Леа Веру познакомит вас с недокументированными приемами, позволяющими найти изящные решения для самого широкого круга задач веб-дизайна. В основу книги легли доклады автора на шестидесяти международных конференциях веб-разработчиков, так что она затрагивает самые актуальные темы - от взаимодействия с пользователем до типографики и визуальных эффектов. Множество книг, доступных на сегодняшнем рынке, документируют возможности CSS от A до Я. Хорошо это или плохо, но «Секреты CSS» - не одна из них. Ее назначение - заполнить пробелы в знаниях, оставшиеся после того, как вы уже ознакомились со справочными материалами, открыть ваш разум новым способам применения функциональности, которая вам уже известна, а также познакомить вас с полезными возможностями CSS, которые не так модны и популярны, но заслуживают не меньшей любви. Главная задача этой книги - научить вас решать проблемы с помощью CSS.

Для кого эта книга

Главная целевая аудитория этой книги - разработчики CSS среднего и продвинутого уровня . Избавившись от информации начального уровня, мы можем посвятить больше времени изучению сложных сценариев использования современных возможностей CSS и их разнообразных комбинаций. Это, однако, означает, что я сделала несколько предположений относительно вашего уровня подготовки, мой дорогой читатель:

Я предполагаю, что CSS 2.1 вы знаете назубок и у вас за плечами несколько лет разработки. Вы не мучаетесь вопросом, как же работает позиционирование. Вы используете генерируемое содержимое для украшения дизайна, не прибегая к помощи лишней разметки или изображений. И вы не развешиваете !important по всему коду, так как действительно понимаете специфичности, наследование и каскадирование. Вы знаете составные части блочной модели и вас не способно расстроить схлопывание полей. Вам знакомы разные единицы изменения длины, и вы знаете, в какой ситуации какую из них лучше применить;

Вы достаточно хорошо знакомы с наиболее популярными возможностями CSS3 - либо из статей, опубликованных в Сети, либо из книг - и пробовали применять их, пусть даже ограничиваясь своими личными проектами. Даже если вы не исследовали их детально, вы знаете, как создать скругленные углы, добавить тень box-shadow или определить линейный градиент. Вы уже поиграли с базовыми двумерными трансформациями и немало времени посвятили изучению базовых переходов и анимации;

У вас есть представление о формате SVG , и вы знаете, для чего он используется, даже если файлы в этом формате вы самостоятельно не создаете;

Вы слышали о препроцессорах CSS и знаете, на что они способны, даже если решили в своей работе их не использовать;

Вы не плаваете в математике уровня средней школы : квадратные корни, теорема Пифагора, синусы, косинусы и логарифмы.

Однако для того чтобы читатели, не удовлетворяющие вышеперечисленным требованиям, также могли наслаждаться книгой, в начале некоторых секретов я добавила врезку «Предварительные требования» , в которой вкратце перечисляю аспекты CSS или предыдущие секреты, с которыми необходимо ознакомиться, чтобы понять и научиться применять текущий секрет. (Сюда, разумеется, не входят возможности CSS 2.1, потому что в этом случае врезка стала бы очень длинной.) Она выглядит так:

Предварительные требования

Знание свойства box-shadow, базовое знание градиентов CSS, секрет «Гибкие эллипсы»

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

Обратите внимание, что я упомянула о «разработчиках CSS» и что «навыки дизайна» среди представленных выше предположений не числятся. Важно помнить, что это не книга о дизайне . Хотя она неизбежно затрагивает определенные принципы дизайна и описывает некоторые улучшения взаимодействия с пользователем, «Секреты CSS» - это в первую очередь книга о решении проблем с кодом . CSS-код порождает некий визуальный результат, но это все еще код, точно такой же, как код SVG, WebGL/OpenGL или JavaScript Canvas API, а не дизайн. Для написания хорошего гибкого CSS требуется такое же аналитическое мышление, что и для программирования. Сегодня, когда большинство людей используют для своего CSS-кода препроцессоры со всеми их переменными, математикой, условными выражениями и циклами, написание кода CSS уже практически неотличимо от программирования!

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

Форматирование и условные обозначения

Эта книга состоит из 47 «секретов», тематически сгруппированных в семь глав. Все эти секреты более-менее независимы и - при условии, что все предварительные требования выполняются, - с ними можно знакомиться в любом порядке. Демонстрационные примеры в каждом из секретов - это не готовые веб-сайты и даже не их части. Я намеренно делала их как можно меньше и проще, для того чтобы их было удобнее изучать. Я исхожу из предположения, что вы уже имеете представление о том, что намереваетесь реализовать. Цель этой книги - предоставлять не дизайнерские идеи, а решения по их реализации.

Каждый секрет разбит на два или более раздела. Первый раздел, озаглавленный «Проблема», содержит описание распространенной проблемы, которую мы будем решать с помощью CSS. Иногда в таком введении я также описываю популярные, но недостаточно хорошие решения данной проблемы (например, решения, требующие объемной разметки, жестко закодированных значений и т. п.) и чаще всего завершаю его одной из вариаций вопроса: существует ли лучший способ реализовать то же самое?

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

Строковый код выделяется моноширинным шрифтом, а названия и коды цветов часто дополняются небольшой цветовой меткой (например, #f06). Блочные фрагменты кода выглядят так:

Background: url("http://adamcatlace.jpg");
или так:

HTML

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

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

JS function $$(selector, context) { context = context || document; var elements = context.querySelectorAll(selector); return Array.prototype.slice.call(elements); }

Занимательная страничка
Врезка с интересной информацией

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

К каждому секрету прилагается один или несколько интерактивных примеров, для доступа к которым используются короткие и легкие в запоминании URL-адреса на сайте http://play.csssecrets.io . Ссылки на них выглядят так:

Будущее
Будущие решения

Врезки «Будущее» содержат описание техник, для которых уже подготовлены черновые спецификации, но которые на момент написания этой книги еще не реализованы. Читателю следует всегда проверять, поддерживаются ли эти техники, так как вполне возможна ситуация, что они были реализованы уже после публикации книги. В случаях, когда возможность настолько малоизвестна, что упоминания о ней может не быть даже на веб- сайтах поддержки браузеров, эта врезка включает ссылку на тест, который читатель может загрузить, перейдя по короткому, легко запоминающемуся URL-адресу, такому, как показан ниже в примере «Протестируйте!». Оформление таких тестов обычно включает оттенки зеленого, когда возможность поддерживается, и оттенки красного в противном случае. Точные инструкции приведены в коде в форме комментариев.

В конце почти всех секретов вы найдете список связанных спецификаций, который выглядит так:

Связанны спецификации

- CSS Backgrounds & Borders
- Selectors
- Scalable Vector Graphics

Сюда входят ссылки на все спецификации, возможности из которых были упомянуты в секрете. Однако так же как и врезка «Предварительные требования», врезка «Связанные спецификации» не включает функциональность CSS 2.1 (http://w3.org/TR/CSS21), иначе одни и те же возможности пришлось бы перечислять после каждого секрета. Это означает, что те несколько секретов, в которых мы обсуждаем только возможности из CSS 2.1, не дополняются врезкой «Связанные спецификации».

Поддержка браузерами и резервные решения

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

Однако большинство представленных здесь секретов либо вполне прилично поддерживаются браузерами, либо для них существуют хорошие резервные решения. Если поддержка браузерами определенной техники находится на слишком низком уровне, вы увидите предупреждающий значок «Ограниченная поддержка» рядом с заголовком соответствующего решения, как здесь, рядом с этим абзацем. Этого должно быть достаточно, для того чтобы вы поняли: не стоит использовать данное решение, не проверив уровень поддержки браузерами, а также не позаботившись о качественных резервных решениях.

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

Background: linear-gradient(90deg, yellow, red);
Однако если вы хотите обеспечить поддержку очень старых браузеров, возможно, в итоге ваш код будет выглядеть примерно так:

Background: -moz-linear-gradient(0deg, yellow, red); background: -o-linear-gradient(0deg, yellow, red); background: -webkit-linear-gradient(0deg, yellow, red); background: linear-gradient(90deg, yellow, red);
Поскольку ландшафт этих различий настолько же нестабилен, как и поддержка браузерами, я ожидаю, что в вашей работе проверка таких вещей будет одним из этапов обязательного исследования перед применением той или иной возможности CSS, поэтому не обсуждаю их в решениях, представленных в данной книге. Аналогично, хорошей практикой считается обеспечение резервных решений, для того чтобы ваши веб-сайты не ломались в старых браузерах, пусть даже ценой более простецкого внешнего вида. Когда обходные решения очевидны, я не заостряю на них внимание, так как предполагаю, что вы знакомы с принципами каскадирования. Например, при определении градиента, скажем, такого, как показанный выше, вы могли бы добавить в самом начале сплошной цвет.

Background: rgb(255, 128, 0); background: -moz-linear-gradient(0deg, yellow, red); background: -o-linear-gradient(0deg, yellow, red); background: -webkit-linear-gradient(0deg, yellow, red); background: linear-gradient(90deg, yellow, red);
Однако иногда каскадирование не позволяет обеспечить надежное резервное решение. Тогда в качестве последнего средства можно прибегнуть к помощи инструментов, подобных Modernizr , которые добавляют классы вроде textshadow или no-textshadow к корневому элементу (), чтобы вы могли с помощью них обращаться к элементам только в том случае, когда нужные возможности действительно поддерживаются (или не поддерживаются) , например:

H1 { color: gray; } .textshadow h1 { color: transparent; text-shadow: 0 0 .3em gray; }
Если возможность, для которой вы пытаетесь создать резервное решение, достаточно новая, то можно использовать правило , «родное» для Modernizr. Например, предыдущий фрагмент кода превратится в такой:

H1 { color: gray; } @supports (text-shadow: 0 0 .3em gray) { h1 { color: transparent; text-shadow: 0 0 .3em gray; } }
Однако к использованию следует подходить с большой осторожностью. Применив его здесь, мы ограничили описываемый эффект не просто браузерами, поддерживающими тени для текста, но и браузерами, поддерживающими дополнительно правило , а это куда более ограниченное множество.

И наконец, всегда есть вариант добавить несколько строк кода JavaScript ручной работы, который будет определять, поддерживается ли возможность, и добавлять классы в корневой элемент так же, как это делает Modernizr. Основной способ, как проверить, поддерживается ли свойство, - посмотреть, существует ли он, воспользовавшись объектом element.style любого элемента:

JS var root = document.documentElement; // if ("textShadow" in root.style) { root.classList.add("textshadow"); } else { root.classList.add("no-textshadow"); }
Если нам нужно проверить несколько свойств, предыдущую проверку легко превратить в функцию:

JS function testProperty(property) { var root = document.documentElement; if (property in root.style) { root.classList.add(property.toLowerCase()); return true; } root.classList.add("no-" + property.toLowerCase()); return false; }
Для того чтобы протестировать значение, нужно присвоить его свойству и проверить, сохранит ли его браузер. Поскольку здесь мы модифицируем стили, а не просто проверяем их существование, в тесте разумно использовать элемент-заглушку:

JS var dummy = document.createElement("p"); dummy.style.backgroundImage = "linear-gradient(red,tan)"; if (dummy.style.backgroundImage) { root.classList.add("lineargradients"); } else { root.classList.add("no-lineargradients"); }
Это также легко преобразуется в функцию:

JS function testValue(id, value, property) { var dummy = document.createElement("p"); dummy.style = value; if (dummy.style) { root.classList.add(id); return true; } root.classList.add("no-" + id); return false; }
Тестирование селекторов и немного сложнее, но выполняется по тому же принципу: когда дело доходит до CSS, браузеры отбрасывают все, что они не понимают, так что для проверки того, была ли возможность распознана, можно динамично применить ее и посмотреть, сохранил ли ее браузер. Необходимо всегда помнить, однако, что даже если браузер в состоянии разобрать синтаксис возможности CSS, это не гарантирует, что таковая возможность реализована правильно и что она вообще реализована в принципе .

Более подробно с книгой можно ознакомиться на сайте издательства
Оглавление
Отрывок

Для Хаброжителей скидка 25% по купону - Веру
Купон действует на книгу, а также на всю серию

Словарь - неупорядоченная структура данных, которая позволяет хранить пары «ключ - значение». Вот пример словаря на Python:

Dictionary = {"персона": "человек", "марафон": "гонка бегунов длиной около 26 миль", "противостоять": "оставаться сильным, несмотря на давление", "бежать": "двигаться со скоростью"}

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

Gender_dict = {0: "муж", 1: "жен"}

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

Dictionary = {(1, 2.0): "кортежи могут быть ключами", 1: "целые числа могут быть ключами", "бежать": "строки тоже", ["носок", 1, 2.0]: "а списки не могут"}

Прим. перев. На самом деле проблема не с изменяемыми, а с нехэшируемыми типами данных, но обычно это одно и то же.

Получение данных из словаря

Для получения значения конкретного ключа используются квадратные скобки . Предположим, что в нашем словаре есть пара "марафон": 26 .

# берём значение с ключом "марафон" dictionary["марафон"]

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

Добавление и обновление ключей

Добавление новых пар в словарь происходит достаточно просто:

# Добавляем ключ "туфля" со значением "род обуви, закрывающей ногу не выше щиколотки" dictionary["туфля"] = "род обуви, закрывающей ногу не выше щиколотки"

Обновление существующих значений происходит абсолютно также:

# Обновляем ключ "туфля" и присваиваем ему значение "хорошая туфля" dictionary["туфля"] = "хорошая туфля"

Удаление ключей

Для удаления ключа и соответствующего значения из словаря можно использовать del

# Удаляем значение с ключом "противостоять" из словаря del dictionary["противостоять"]

Методы

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

Update

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

# Добавляем две пары в словарь dictionary, используя метод update dictionary.update({"бежал": "бежать в прошедшем времени", "туфли": "туфля во множественном числе"}) >>> dictionary {"марафон": "гонка бегунов длиной около 26 миль", "персона": "человек", "бежал": "бежать в прошедшем времени", "бежать": "двигаться со скоростью", "туфля": "род обуви, закрывающей ногу не выше щиколотки", "туфли": "туфля во множественном числе"}

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

Get

# Допустим, у нас есть словарь story_count story_count = {"сто": 100, "девяносто": 90, "двенадцать": 12, "пять": 5}

Метод get() возвращает значение по указанному ключу. Если указанного ключа не существует, метод вернёт None .

# Ключ "двенадцать" существует и метод get в данном случае вернёт 12 story_count.get("двенадцать")

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

>>> story_count.get("два") None

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

# Метод вернёт 0 в случае, если данного ключа не существует story_count.get("два", 0)

Pop

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

>>> story_count.pop("девяносто") 90 >>> story_count {"двенадцать": 12, "сто": 100, "пять": 5}

Keys

Метод keys() возвращает коллекцию ключей в словаре.

>>> story_count.keys() ["сто", "пять", "двенадцать"]

Values

Метод values() возвращает коллекцию значений в словаре.

>>> story_count.values()

Items

Метод items() возвращает пары «ключ - значение».

>>> dictionary.items() [("персона", "человек"), ("бежать", "двигаться со скоростью"), ("туфля", "род обуви, закрывающей ногу не выше щиколотки"), ("бежал", "бежать в прошедшем времени"), ("марафон", "гонка бегунов длиной около 26 миль"), ("туфли", "туфля во множественном числе")]

Итерация через словарь

Вы можете провести итерацию по каждому ключу в словаре.

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

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

Словарь выглядит так:

Чтобы отделить ключ от значения, в словарях используются символы двоеточия. Пары «ключ: значение» отделяются друг от друга запятыми.

Ключи всегда находятся слева от двоеточия. Ключ может быть представлен любым неизменяемым типом данных. В приведённом выше примере содержатся такие ключи:

• ‘username’
• ‘online’
• ‘followers’

В данном случае ключи выражены строками.

Слева от двоеточия находятся значения. Значение может выражаться любым типом данных. В словаре выше мы видим такие значения:

• ‘8host-blog’

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

Читайте также:

Попробуйте отобразить словарь 8host:

print(8host)
{"username": "8host-blog", "followers": 987, "online": True}

Обратите внимание: порядок пар «ключ: значение» изменился. Это произошло потому, что словари являются неупорядоченным типом данных. В отличие от списков и кортежей, словари не сохраняют порядок своих элементов и, соответственно, не индексируются.

Читайте также:

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

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

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

Доступ к данным по ключу

Словари могут стать важной частью разработанной в Python программы.

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

print(8host["username"])
8host-blog

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

Таким же образом можно вызвать и остальные значения этого словаря:

print(8host["followers"])
987
print(8host["online"])
True

Доступ к данным с помощью функций

Доступ к значениям можно получить не только с помощью ключей, но и при помощи функций.

• dict.keys() – выводит ключи словаря.
• dict.values() – выводит значения словаря.
• dict.items() – выводит пары в виде кортежа (ключ, значение).

Попробуйте использовать функцию dict.keys(), чтобы получить ключи словаря. Передайте переменную 8host.keys() функции print().

print(8host.keys())
dict_keys(["followers", "username", "online"])

Ключи возвращаются в виде итерируемого объекта класса dict_keys и отображаются в формате списка.

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

8host = {"username": "8host-blog", "online": True, "followers": 987}
jesse = {"username": "Jesse", "online": False, "points": 723}
for common_key in 8host.keys() & jesse.keys():
print(сайтmon_key], jesse)

Словари 8host и jesse содержат данные о профилях пользователей.

Эти профили отличаются: первый – профиль для социальных сетей, второй – профиль для игр. Однако у них совпадают два ключа: username и online. Чтобы убедиться в этом, запустите программу, и она выдаст:

8host-blog Jesse
True False

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

Функция dict.values() используется аналогичным образом и возвращает значения заданного словаря. Например:

8host = {"username": "8host-blog", "online": True, "followers": 987}
print(8host.values())
dict_values()

Методы keys() и values() возвращают неотсортированные ключи или значения словаря 8host в виде объектов dict_keys и dict_values соответственно.

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

print(8host.items())
dict_items([("online", True), ("username", "8host-blog"), ("followers", 987)])

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

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

for key, value in 8host.items():
print(key, "is the key for the value", value)
online is the key for the value True
followers is the key for the value 987
username is the key for the value 8host-blog

Цикл for выполнил итерацию списков ключей и значений и вывел результат построчно.

Редактирование словарей

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

Добавление и изменение элементов словарей

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

dict = value

Попробуйте добавить в словарь новую пару. Например:

usernames = {"8host": "8host-blog", "Jamie": "jamie54"}
usernames["Drew"] = "iam-drew"
print(usernames)
{"Drew": "iam-drew", "8host": "8host-blog", "Jamie": "jamie54"}

Как видите, в словаре появилась новая пара ‘Drew’: ‘iam-drew’.

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

Давайте рассмотрим словарь drew, который содержит данные об одном из пользователей этой сети. Предположим, сегодня количество его подписчиков заметно увеличилось, потому нужно обновить значение его ключа ‘followers’. Чтобы убедиться, что значение было изменено, используйте функцию print().

drew = {"username": "iam-drew", "online": True, "followers": 305}
drew["followers"] = 342
print(drew)
{"username": "iam-drew", "followers": 342, "online": True}

Как видите, значение ключа followers было изменено.

Этот метод позволяет добавлять данные в словарь путём пользовательского ввода. Создайте простую программу для командной строки, usernames.py, которая позволит пользователям добавлять данные в словарь.

# Определить исходный словарь
usernames = {"8host": "8host-blog", "Jamie": "jamie54"}
# Добавить цикл while
while True:
# Запросить имя
print("Enter a name:")
# Присвоить его переменной
name = input()
# Проверить, есть ли такое имя в словаре и вывести результат
if name in usernames:
print(usernames + " is the username of " + name)
# Если имени нет…
else:
# Вывести на экран
print("I don\"t have " + name + "\"s username, what is it?")
# Добавить имя пользователя для такого имени
username = input()
# Присвоить имя пользователя ключу
usernames = username
# Сообщить об обновлении данных
print("Data updated.")

Запустите программу с помощью командной строки:

python usernames.py

Она выведен на экран:

Enter a name:
8host
8host-blog is the username of 8hosts
Enter a name:
Jesse
I don"t have Jesse"s username, what is it?
Jesse
Data updated.
Enter a name:

Чтобы остановить программу, нажмите CTRL + C.

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

Можно выделить несколько отличительных характеристик словарей:

1. Для доступа к ним используется не индекс, а ключ. Аналогично спискам, в словарях есть возможность получения доступа к элементам цикла по ключам.
2. Для хранения словарей используется неотсортированный порядок, кроме того, допускается сохранение ключей в порядке, отличном от порядка их добавления.
3. Аналогично список, в словаре могут быть вложенные словари. Значениями словаря могут быть объекты любого типа (heterogeneous). Ключ словаря – immutable тип может являться float, целым числом, строкой или кортежем, включающим указанные типы.
4. Словарь имеет вид хеш-таблицы быстрого доступа.
5. Аналогично спискам, словари не хранят непосредственно объекты, а только ссылки на них.

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

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

С словарем проводится две основные операции – сохранение с указанным ключом, а также извлечение значения по нему. Инструмент del дает возможность удаления пары key: value.

Метод keys () для словарей используется с целью возвращения списка всех применяемых ключей в произвольном порядке. Чтобы отсортировать список необходимо пользоваться методом sort (). Чтобы определить наличие конкретного ключа следует пользоваться методом has key(), однако в 3-й версии он уже устаревший и вместо него следует пользоваться оператором in. Чтобы добавить в словарь новый объект не нужно проводить предварительные проверки: если у ключа дор этого уже было определенное значение, то произойдет его перезапись.

Как пример возьмем работу с электронным досье Васи Пупкина.

# создадим пустой словарь data = {} # или так data = dict() # определим его длину - 0 len(data) # заполним данными - имя и фамилия data = {"firstname": "Vasya", "lastname": "Pupkin"} # длина словаря определяется количеством ключей # на данный момент - 2 len(data) # добавим отчество data["middlename"] = "Vasilyevich" # после женитьбы Васи обновляем поле фамилии и добавляем банковский счет data.update({"lastname":"Gates", "bank_account": 10000000}) # добавляем новым элементом словарь с данными жены... data["wife"] = {"firstname": "Annet", "lastname": "Gates", "middlename": "Billovna"} # ... и загоняем в гараж приданое data["garage"] = ["Jaguar", "Toyota Camry"] # и еще одну машинку data["garage"].append("Honda Civic") # узнаем имя жены - Annet print data["wife"]["firstname"] # Вася хвастается друзьям print data["bank_account"] # если нет элемента с нужным ключом, # можно избежать ошибки if "bank_account" in data: print data["bank_account"] else: print "no money" # или так print data.get("bank_account", 0) # закрываем счет del data["bank_account"] # распечатываем досье for key in data: print key, ":", data #### после распечатки выдаст следующее # firstname: Vasya # wife: {"middlename": "Billovna", "lastname": "Gates", "firstname": "Annet"} # middlename: Vasilyevich # lastname: Gates # garage: ["Jaguar", "Toyota Camry", "Honda Civic"] #### а само досье выглядит так # {"firstname": "Vasya", "wife": {"middlename": "Billovna", "lastname": "Gates", # "firstname": "Annet"}, "middlename": "Vasilyevich", "lastname": "Gates", # "garage": ["Jaguar", "Toyota Camry", "Honda Civic"]}

На этом, пожалуй, все.

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

Словари в 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"

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

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

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

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. Существующие ключи перезаписываются. Возвращает None (не новый словарь!).

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