Python dictionary (dict) tutorial

Python NumPy

NumPy IntroNumPy Getting StartedNumPy Creating ArraysNumPy Array IndexingNumPy Array SlicingNumPy Data TypesNumPy Copy vs ViewNumPy Array ShapeNumPy Array ReshapeNumPy Array IteratingNumPy Array JoinNumPy Array SplitNumPy Array SearchNumPy Array SortNumPy Array FilterNumPy Random
Random Intro
Data Distribution
Random Permutation
Seaborn Module
Normal Distribution
Binomial Distribution
Poisson Distribution
Uniform Distribution
Logistic Distribution
Multinomial Distribution
Exponential Distribution
Chi Square Distribution
Rayleigh Distribution
Pareto Distribution
Zipf Distribution

NumPy ufunc
ufunc Intro
ufunc Create Function
ufunc Simple Arithmetic
ufunc Rounding Decimals
ufunc Logs
ufunc Summations
ufunc Products
ufunc Differences
ufunc Finding LCM
ufunc Finding GCD
ufunc Trigonometric
ufunc Hyperbolic
ufunc Set Operations

Перебор элементов словаря в цикле for

How to reverse a list in python

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

>>> nums
{1: 'one', 2: 'two', 3: 'three'}
>>> for i in nums:
...     print(i)
... 
1
2
3

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

>>> for i in nums:
...     print(numsi)
... 
one
two
three

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

>>> n = nums.items()
>>> n
dict_items()

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

>>> for key, value in nums.items():
...     print(key, 'is', value)
... 
1 is one
2 is two
3 is three

Методы словаря keys() и values() позволяют получить отдельно перечни ключей и значений. Так что если, например, надо перебрать только значения или только ключи, лучше воспользоваться одним из этих методов:

>>> v_nums = 
>>> for v in nums.values():
...     v_nums.append(v)
... 
>>> v_nums

Using TypedDict Types

Strings and character data in python

Here is an example of how the type Movie can be used:

movie: Movie = {'name': 'Blade Runner',
                'year': 1982}

An explicit Movie type annotation is generally needed, as
otherwise an ordinary dictionary type could be assumed by a type
checker, for backwards compatibility. When a type checker can infer
that a constructed dictionary object should be a TypedDict, an
explicit annotation can be omitted. A typical example is a dictionary
object as a function argument. In this example, a type checker is
expected to infer that the dictionary argument should be understood as
a TypedDict:

def record_movie(movie: Movie) -> None: ...

record_movie({'name': 'Blade Runner', 'year': 1982})

Another example where a type checker should treat a dictionary display
as a TypedDict is in an assignment to a variable with a previously
declared TypedDict type:

movie: Movie
...
movie = {'name': 'Blade Runner', 'year': 1982}

Operations on movie can be checked by a static type checker:

movie = 'Ridley Scott'  # Error: invalid key 'director'
movie = '1982'  # Error: invalid value type ("int" expected)

The code below should be rejected, since 'title' is not a valid
key, and the 'name' key is missing:

movie2: Movie = {'title': 'Blade Runner',
                 'year': 1982}

The created TypedDict type object is not a real class object. Here
are the only uses of the type a type checker is expected to allow:

It can be used in type annotations and in any context where an
arbitrary type hint is valid, such as in type aliases and as the
target type of a cast.
It can be used as a callable object with keyword arguments
corresponding to the TypedDict items. Non-keyword arguments are not
allowed. Example:
```
m = Movie(name='Blade Runner', year=1982)
```
When called, the TypedDict type object returns an ordinary
dictionary object at runtime:
```
print(type(m))  # <class 'dict'>
```
It can be used as a base class, but only when defining a derived
TypedDict. This is discussed in more detail below.

In particular, TypedDict type objects cannot be used in
isinstance() tests such as isinstance(d, Movie). The reason is
that there is no existing support for checking types of dictionary
item values, since isinstance() does not work with many PEP 484
types, including common ones like List. This would be needed
for cases like this:

class Strings(TypedDict):
    items: List

print(isinstance({'items': }, Strings))    # Should be False
print(isinstance({'items': }, Strings))  # Should be True

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

Генераторы в python и их отличие от списков и функций

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

Capitals = {'Russia': 'Moscow', 'Ukraine': 'Kiev', 'USA': 'Washington'}
Capitals = dict(Russia = 'Moscow', Ukraine = 'Kiev', USA = 'Washington')
Capitals = dict()
Capitals = dict(zip(, ))
print(Capitals)

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

Nested Dictionaries

A dictionary can also contain many dictionaries, this is called nested
dictionaries.

Example

Create a dictionary that contain three dictionaries:

myfamily = { «child1» : {    «name» : «Emil»,
    «year» : 2004 }, «child2» : {
«name» : «Tobias»,    «year» : 2007 },
«child3» : {    «name» : «Linus»,
    «year» : 2011 }}

Or, if you want to nest three dictionaries that already exists as
dictionaries:

Example

Create three dictionaries, then create one dictionary that will contain the
other three dictionaries:

child1 = { «name» : «Emil», «year» : 2004}child2 = {
«name» : «Tobias», «year» : 2007}child3 = { «name» : «Linus»,
«year» : 2011}myfamily = { «child1» : child1,
«child2» : child2, «child3» : child3}

Supported and Unsupported Operations

Type checkers should support restricted forms of most dict
operations on TypedDict objects. The guiding principle is that
operations not involving Any types should be rejected by type
checkers if they may violate runtime type safety. Here are some of
the most important type safety violations to prevent:

A required key is missing.
A value has an invalid type.
A key that is not defined in the TypedDict type is added.

A key that is not a literal should generally be rejected, since its
value is unknown during type checking, and thus can cause some of the
above violations. (
generalizes this to cover final names and literal types.)

The use of a key that is not known to exist should be reported as an
error, even if this wouldn’t necessarily generate a runtime type
error. These are often mistakes, and these may insert values with an
invalid type if structural subtyping hides the types of certain items.
For example, d = 1 should generate a type check error if
'x' is not a valid key for d (which is assumed to be a
TypedDict type).

Extra keys included in TypedDict object construction should also be
caught. In this example, the director key is not defined in
Movie and is expected to generate an error from a type checker:

m: Movie = dict(
    name='Alien',
    year=1979,
    director='Ridley Scott')  # error: Unexpected key 'director'

Type checkers should reject the following operations on TypedDict
objects as unsafe, even though they are valid for normal dictionaries:

Operations with arbitrary str keys (instead of string literals
or other expressions with known string values) should generally be
rejected. This involves both destructive operations such as setting
an item and read-only operations such as subscription expressions.
As an exception to the above rule, d.get(e) and e in d
should be allowed for TypedDict objects, for an arbitrary expression
e with type str. The motivation is that these are safe and
can be useful for introspecting TypedDict objects. The static type
of d.get(e) should be object if the string value of e
cannot be determined statically.
clear() is not safe since it could remove required keys, some of
which may not be directly visible because of structural
subtyping. popitem() is similarly unsafe, even if all known
keys are not required (total=False).
del obj should be rejected unless 'key' is a
non-required key.

Type checkers may allow reading an item using d even if
the key 'x' is not required, instead of requiring the use of
d.get('x') or an explicit 'x' in d check. The rationale is
that tracking the existence of keys is difficult to implement in full
generality, and that disallowing this could require many changes to
existing code.

Iterator objects

In Python 2.2, dict objects gained support for the then-new iterator
protocol, allowing direct iteration over the keys stored in the dictionary,
thus avoiding the need to build a list just to iterate over the dictionary
contents one entry at a time. iter(d) provides direct access to the
iterator object for the keys.

Python 2 also provides a d.iterkeys() method that is essentially
synonymous with iter(d), along with d.itervalues() and
d.iteritems() methods.

These iterators provide live views of the underlying object, and hence may
fail if the set of keys in the underlying object is changed during
iteration:

>>> d = dict(a=1)
>>> for k in d:
...     del d
...
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
RuntimeError: dictionary changed size during iteration

As iterators, iteration over these objects is also a one-time operation:
once the iterator is exhausted, you have to go back to the original mapping
in order to iterate again.

In Python 3, direct iteration over mappings works the same way as it does
in Python 2. There are no method based equivalents — the semantic equivalents
of d.itervalues() and d.iteritems() in Python 3 are
iter(d.values()) and iter(d.items()).

Other Dictionary Operations

Dictionary Membership Test

We can test if a is in a dictionary or not using the keyword . Notice that the membership test is only for the and not for the .

Output

True
True
False

We can iterate through each key in a dictionary using a loop.

Output

Dictionary Built-in Functions

Built-in functions like , , , , , etc. are commonly used with dictionaries to perform different tasks.

Function	Description
all()	Return if all keys of the dictionary are True (or if the dictionary is empty).
any()	Return if any key of the dictionary is true. If the dictionary is empty, return .
len()	Return the length (the number of items) in the dictionary.
cmp()	Compares items of two dictionaries. (Not available in Python 3)
sorted()	Return a new sorted list of keys in the dictionary.

Here are some examples that use built-in functions to work with a dictionary.

Output

False
True
6

1. Что такое словарь

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

Основные операции над словарем — сохранение с заданным ключом и извлечение по нему значения. Также можно удалить пару с помощью инструкции .

Метод для словаря возвращает список всех используемых ключей в произвольном порядке; для сортировки списка нужно применить метод . Для определения наличия определенного ключа есть метод , который в версии 3.0 успеет устареть — вместо него есть оператор . Добавление нового объекта в словарь не требует предварительных проверок: если ранее ключу уже соответствовало некоторое значение, оно будет перезаписано.

Пример — словарь в качестве телефонного справочника:

>>> dic = {'vanya' : 23323223, 'smith' : 32232332}
>>> dic = 33332222
>>> dic
{'vanya': 23323223, 'fedya': 33332222, 'smith': 32232332}
>>> dic
32232332
>>> del dic
>>> dic
{'fedya': 33332222, 'smith': 32232332}
>>> dic.keys()

>>> dic.has_key('fedya')
True

Создать словарь можно несколькими способами:

Обычное выражение — оно удобно, если словарь статичен:
```
    D = {'name': 'mel', 'age': 45}
```
Динамический вариант создания на лету:
```
    D = {}
    D = 'mel'
    D = 45
```
С помощью функции dict() — ключи при этом должны быть строками. С помощью этой функции можно избавить себя от обязательного условия заключать ключ в кавычки. В примере приведены четыре варианта создания одного и того же словаря:
```
    d1 = dict(id=1948, name="Washer", size=3)
    d2 = dict({"id": 1948, "name": "Washer", "size": 3})
    d3 = dict()
    d4 = dict(zip(("id", "name", "size"), (1948, "Washer", 3)))
```
С помощью — создает словарь по списку ключей с пустыми значениями:
```
    D = {}.fromkeys(,123)
```

С помощью конструктора:

    d = dict((x, x**2) for x in xrange(5))

Значения нотации «О» большое

На письме временная сложность алгоритма обозначается как O(n), где n — размер входной коллекции.

O(1)

Обозначение константной временной сложности. Независимо от размера коллекции, время, необходимое для выполнения операции, константно. Это обозначение константной временной сложности. Эти операции выполняются настолько быстро, насколько возможно. Например, операции, которые проверяют, есть ли внутри коллекции элементы, имеют сложность O(1).

O(log n)

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

O(n)

Обозначение линейной временной сложности. Время, необходимое для выполнения операции, прямо и линейно пропорционально количеству элементов в коллекции. Это обозначение линейной временной сложности. Это что-то среднее с точки зрения производительности. Например, если мы хотим суммировать все элементы в коллекции, нужно будет выполнить итерацию по коллекции. Следовательно, итерация коллекции является операцией O(n).

O(n log n)

Обозначение квазилинейной временной сложности. Скорость выполнения операции является квазилинейной функцией числа элементов в коллекции. Временная сложность оптимизированного алгоритма сортировки обычно равна O(n log n).

O(n^2)

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

O(n!)

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

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

Примеры

Пример 1. Подсчитаем, сколько раз в строке встречается каждый символ:

def histogram(s):
    d = dict()
    for c in s:
        if c not in d:d = 1
        else:d += 1
    return d
hist = histogram('how many times')
>>> {'a': 1,'e': 1,'i': 1,'h': 1,'m': 2,'o': 1,'n': 1,'s': 1,'t': 1,'w': 1,'y': 1}

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

def invert_dict(d):
    inv = dict()
    for key in d:
        val = d
        if val not in inv:inv = 
        else:inv.append(key)
    return inv
print invert_dict(hist)
>>> {1: , 2: }

Пример 2. Подсчитать частоту повторов каждого уникального слова в файле:

import string
import sys
words = {}
strip = string.whitespace + string.punctuation + string.digits + "\"'"
filename = 'file'
for line in open(filename):
    for word in line.lower().split():
        word = word.strip(strip)
        if len(word) > 2:
            words = words.get(word, 0) + 1
for word in sorted(words):
    print("'{0}' occurs {1} times".format(word, words))

Пример 3. Сортировка словаря по ключам:

author = {"php":"Rasmus Lerdorf",\
    "perl":"Larry Wall",\
    "tcl":"John Ousterhout",\
    "awk":"Brian Kernighan",\
    "java":"James Gosling",\
    "parrot":"Simon Cozens",\
    "python":"Guido van Rossum"}
#Либо так:
langs = author.keys()
langs.sort()
for language in langs:
    print language," - ",author
#либо так:
for key in sorted(author.iterkeys()):
    print "%s: %s" % (key, author)
   
>>> awk  -  Brian Kernighan
>>> java  -  James Gosling
>>> parrot  -  Simon Cozens
>>> perl  -  Larry Wall
>>> php  -  Rasmus Lerdorf
>>> python  -  Guido van Rossum
>>> tcl  -  John Ousterhout

Пример 4. Как инвертировать словарь, т.е. поменять ключи со значениями:

def invert_dict_nonunique(d):
    newdict = {}
    for k, v in d.iteritems():
        newdict.setdefault(v, []).append(k)
    return newdict
d = {'child1': 'parent1','child2': 'parent1','child3': 'parent2','child4': 'parent2'}
print invert_dict_nonunique(d)
>>> {'parent2': , 'parent1': }

Python NumPy

Alternative Syntax

This PEP also proposes an alternative syntax that can be backported to
older Python versions such as 3.5 and 2.7 that don’t support the
variable definition syntax introduced in PEP 526 . It
resembles the traditional syntax for defining named tuples:

Movie = TypedDict('Movie', {'name': str, 'year': int})

It is also possible to specify totality using the alternative syntax:

Movie = TypedDict('Movie',
                  {'name': str, 'year': int},
                  total=False)

The semantics are equivalent to the class-based syntax. This syntax
doesn’t support inheritance, however, and there is no way to
have both required and non-required fields in a single type. The
motivation for this is keeping the backwards compatible syntax as
simple as possible while covering the most common use cases.

Removing Items

There are several methods to remove items from a dictionary:

Example

The method removes the item with the specified key name:

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

Example

The method removes the last
inserted item (in versions before 3.7, a random item is removed instead):

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

Example

The keyword removes the item with the specified
key name:

thisdict = {
  «brand»: «Ford»,
  «model»: «Mustang»,
  «year»: 1964
}del thisdictprint(thisdict)

Example

The keyword can also delete the
dictionary completely:

thisdict = {
  «brand»: «Ford»,
  «model»: «Mustang»,
  «year»: 1964
}del thisdictprint(thisdict) #this will cause an error because «thisdict»
no longer exists.

Example

The method empties the
dictionary:

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

Python NumPy

Iterating over Dictionary using for loop

We can iterate over a dictionary using the for loop. There are many ways to use for loop with a dictionary.

1. Loop through key-value pairs using items() function

fruits_dict = {"1": "Apple", "2": "Banana", "3": "Orange"}

for key, value in fruits_dict.items():
    print(f'{key}={value}')

Output:

1=Apple
2=Banana
3=Orange

fruits_dict = {"1": "Apple", "2": "Banana", "3": "Orange"}

for key in fruits_dict:
    print(key)

Output:

1
2
3

3. Loop through Dictionary Values using values() function

We can use values() function to get the values and then iterate over it.

fruits_dict = {"1": "Apple", "2": "Banana", "3": "Orange"}

for value in fruits_dict.values():
    print(value)

Output:

Apple
Banana
Orange

Properties of Dictionary Keys

Dictionary values have no restrictions. They can be any arbitrary Python object, either standard objects or user-defined objects. However, same is not true for the keys.

There are two important points to remember about dictionary keys −

(a) More than one entry per key is not allowed. This means no duplicate key is allowed. When duplicate keys are encountered during assignment, the last assignment wins. For example −

#!/usr/bin/python3

dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}
print ("dict: ", dict)

When the above code is executed, it produces the following result −

dict:  Manni

(b) Keys must be immutable. This means you can use strings, numbers or tuples as dictionary keys but something like is not allowed. Following is a simple example −

#!/usr/bin/python3

dict = {: 'Zara', 'Age': 7}
print ("dict: ", dict)

When the above code is executed, it produces the following result −

Traceback (most recent call last):
   File "test.py", line 3, in <module>
      dict = {: 'Zara', 'Age': 7}
TypeError: list objects are unhashable

Nested Dictionaries

A dictionary can also contain many dictionaries, this is called nested
dictionaries.

Example

Create a dictionary that contain three dictionaries:

myfamily = { «child1» : {    «name» : «Emil»,
    «year» : 2004 }, «child2» : {
«name» : «Tobias»,    «year» : 2007 },
«child3» : {    «name» : «Linus»,
    «year» : 2011 }}

Or, if you want to nest three dictionaries that already exists as
dictionaries:

Example

Create three dictionaries, than create one dictionary that will contain the
other three dictionaries:

Практическая работа

Создайте словарь, связав его с переменной school, и наполните данными, которые бы отражали количество учащихся в разных классах (1а, 1б, 2б, 6а, 7в и т. п.). Внесите изменения в словарь согласно следующему: а) в одном из классов изменилось количество учащихся, б) в школе появился новый класс, с) в школе был расформирован (удален) другой класс. Вычислите общее количество учащихся в школе.
Создайте словарь, где ключами являются числа, а значениями – строки. Примените к нему метод items(), полученный объект dict_items передайте в написанную вами функцию, которая создает и возвращает новый словарь, «обратный» исходному, т. е. ключами являются строки, а значениями – числа.

Built-in Dictionary Functions and Methods

Python includes the following dictionary functions −

Sr.No.	Function & Description
1	cmp(dict1, dict2) No longer available in Python 3.
2	len(dict) Gives the total length of the dictionary. This would be equal to the number of items in the dictionary.
3	str(dict) Produces a printable string representation of a dictionary
4	type(variable) Returns the type of the passed variable. If passed variable is dictionary, then it would return a dictionary type.

Python includes the following dictionary methods −

Sr.No.	Method & Description
1	dict.clear() Removes all elements of dictionary dict
2	dict.copy() Returns a shallow copy of dictionary dict
3	dict.fromkeys() Create a new dictionary with keys from seq and values set to value.
4	dict.get(key, default=None) For key key, returns value or default if key not in dictionary
5	dict.has_key(key) Removed, use the in operation instead.
6	dict.items() Returns a list of dict‘s (key, value) tuple pairs
7	dict.keys() Returns list of dictionary dict’s keys
8	dict.setdefault(key, default = None) Similar to get(), but will set dict = default if key is not already in dict
9	dict.update(dict2) Adds dictionary dict2‘s key-values pairs to dict
10	dict.values() Returns list of dictionary dict‘s values

Previous Page
Print Page