Генерация неопределенного количества значений

>>> import itertools

>>> for i in itertools.count():

if i > 10: break

print(i, end=" ")

 

0 1 2 3 4 5 6 7 8 9 10

>>> list(zip(itertools.count(), "абвгд"))

[(0, 'а'), (1, 'б'), (2, 'в'), (3, 'г'), (4, 'д')]

>>> list(zip(itertools.count(start=2, step=2), "абвгд"))

[(2, 'а'), (4, 'б'), (6, 'в'), (8, 'г'), (10, 'д')]

 

 

>>> n = 1

>>> for i in itertools.cycle("абв"):

if n > 10: break

print(i, end=" ")

n += 1

 

а б в а б в а б в а

>>> list(zip(itertools.cycle([0, 1]), "абвгд"))

[(0, 'а'), (1, 'б'), (0, 'в'), (1, 'г'), (0, 'д')]

 

 

>>> list(itertools.repeat(1, 10))

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

>>> list(zip(itertools.repeat(5), "абвгд"))

[(5, 'а'), (5, 'б'), (5, 'в'), (5, 'г'), (5, 'д')]

Генерация комбинаций значений

>>> import itertools

>>> list(itertools.combinations('абвг', 2))

[('а', 'б'), ('а', 'в'), ('а', 'г'), ('б', 'в'), ('б', 'г'),

('в', 'г')]

>>> ["".join(i) for i in itertools.combinations('абвг', 2)]

['аб', 'ав', 'аг', 'бв', 'бг', 'вг']

>>> list(itertools.combinations('вгаб', 2))

[('в', 'г'), ('в', 'а'), ('в', 'б'), ('г', 'а'), ('г', 'б'),

('а', 'б')]

>>> list(itertools.combinations('абвг', 3))

[('а', 'б', 'в'), ('а', 'б', 'г'), ('а', 'в', 'г'),

('б', 'в', 'г')]

 

 

>>> list(itertools.combinations_with_replacement('абвг', 2))

[('а', 'а'), ('а', 'б'), ('а', 'в'), ('а', 'г'), ('б', 'б'),

('б', 'в'), ('б', 'г'), ('в', 'в'), ('в', 'г'), ('г', 'г')]

>>> list(itertools.combinations_with_replacement('вгаб', 2))

[('в', 'в'), ('в', 'г'), ('в', 'а'), ('в', 'б'), ('г', 'г'),

('г', 'а'), ('г', 'б'), ('а', 'а'), ('а', 'б'), ('б', 'б')]

 

 

>>> list(itertools.permutations('абвг', 2))

[('а', 'б'), ('а', 'в'), ('а', 'г'), ('б', 'а'), ('б', 'в'),

('б', 'г'), ('в', 'а'), ('в', 'б'), ('в', 'г'), ('г', 'а'),

('г', 'б'), ('г', 'в')]

>>> ["".join(i) for i in itertools.permutations('абвг')]

['абвг', 'абгв', 'авбг', 'авгб', 'агбв', 'агвб', 'бавг',

'багв', 'бваг', 'бвга', 'бгав', 'бгва', 'вабг', 'вагб',

'вбаг', 'вбга', 'вгаб', 'вгба', 'габв', 'гавб', 'гбав',

'гбва', 'гваб', 'гвба']

 

 

>>> from itertools import product

>>> list(product('абвг', repeat=2))

[('а', 'а'), ('а', 'б'), ('а', 'в'), ('а', 'г'), ('б', 'а'),

('б', 'б'), ('б', 'в'), ('б', 'г'), ('в', 'а'), ('в', 'б'),

('в', 'в'), ('в', 'г'), ('г', 'а'), ('г', 'б'), ('г', 'в'),

('г', 'г')]

>>> ["".join(i) for i in product('аб', 'вг', repeat=1)]

['ав', 'аг', 'бв', 'бг']

>>> ["".join(i) for i in product('аб', 'вг', repeat=2)]

['авав', 'аваг', 'авбв', 'авбг', 'агав', 'агаг', 'агбв',

'агбг', 'бвав', 'бваг', 'бвбв', 'бвбг', 'бгав', 'бгаг',

'бгбв', 'бгбг']

Фильтрация элементов последовательности

>>> import itertools

>>> def func(x): return x > 3

 

>>> list(itertools.filterfalse(func, [4, 5, 6, 0, 7, 2, 3]))

[0, 2, 3]

>>> list(filter(func, [4, 5, 6, 0, 7, 2, 3]))

[4, 5, 6, 7]

 

 

>>> list(itertools.filterfalse(None, [0, 5, 6, 0, 7, 0, 3]))

[0, 0, 0]

>>> list(filter(None, [0, 5, 6, 0, 7, 0, 3]))

[5, 6, 7, 3]

 

 

>>> def func(x): return x > 3

 

>>> list(itertools.dropwhile(func, [4, 5, 6, 0, 7, 2, 3]))

[0, 7, 2, 3]

>>> list(itertools.dropwhile(func, [4, 5, 6, 7, 8]))

[]

>>> list(itertools.dropwhile(func, [1, 2, 4, 5, 6, 7, 8]))

[1, 2, 4, 5, 6, 7, 8]

 

 

>>> def func(x): return x > 3

 

>>> list(itertools.takewhile(func, [4, 5, 6, 0, 7, 2, 3]))

[4, 5, 6]

>>> list(itertools.takewhile(func, [4, 5, 6, 7, 8]))

[4, 5, 6, 7, 8]

>>> list(itertools.takewhile(func, [1, 2, 4, 5, 6, 7, 8]))

[]

 

 

>>> list(itertools.compress('абвгде', [1, 0, 0, 0, 1, 1]))

['а', 'д', 'е']

>>> list(itertools.compress('абвгде', [True, False, True]))

['а', 'в']

Прочие функции

>>> list(itertools.islice("абвгдезж", 3))

['а', 'б', 'в']

>>> list(itertools.islice("абвгдезж", 3, 6))

['г', 'д', 'е']

>>> list(itertools.islice("абвгдезж", 3, 6, 2))

['г', 'е']

 

 

>>> import itertools

>>> def func1(x, y): return x + y

 

>>> list(itertools.starmap(func1, [(1, 2), (4, 5), (6, 7)]))

[3, 9, 13]

>>> def func2(x, y, z): return x + y + z

 

>>> list(itertools.starmap(func2, [(1, 2, 3), (4, 5, 6)]))

[6, 15]

 

 

>>> list(itertools.zip_longest([1, 2, 3], [4, 5, 6]))

[(1, 4), (2, 5), (3, 6)]

>>> list(itertools.zip_longest([1, 2, 3], [4]))

[(1, 4), (2, None), (3, None)]

>>> list(itertools.zip_longest([1, 2, 3], [4], fillvalue=0))

[(1, 4), (2, 0), (3, 0)]

>>> list(zip([1, 2, 3], [4]))

[(1, 4)]

 

 

>>> # Выполняем сложение

>>> list(itertools.accumulate([1, 2, 3, 4, 5, 6]))

[1, 3, 6, 10, 15, 21]

>>> # [1, 1+2, 3+3, 6+4, 10+5, 15+6]

>>> # Выполняем умножение

>>> def func(x, y): return x * y

 

>>> list(itertools.accumulate([1, 2, 3, 4, 5, 6], func))

[1, 2, 6, 24, 120, 720]

>>> # [1, 1*2, 2*3, 6*4, 24*5, 120*6]

 

 

>>> arr1, arr2, arr3 = [1, 2, 3], [4, 5], [6, 7, 8, 9]

>>> list(itertools.chain(arr1, arr2, arr3))

[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(itertools.chain("abc", "defg", "hij"))

['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

>>> list(itertools.chain("abc", ["defg", "hij"]))

['a', 'b', 'c', 'defg', 'hij']

 

 

>>> list(itertools.chain.from_iterable(["abc", "defg", "hij"]))

['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

 

 

>>> arr = [1, 2, 3]

>>> itertools.tee(arr)

(<itertools.tee object at 0x00FD8760>,

<itertools.tee object at 0x00FD8738>)

>>> itertools.tee(arr, 3)

(<itertools.tee object at 0x00FD8710>,

<itertools.tee object at 0x00FD87D8>,

<itertools.tee object at 0x00FD87B0>)

>>> list(itertools.tee(arr)[0])

[1, 2, 3]

>>> list(itertools.tee(arr)[1])

[1, 2, 3]

Словари

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

>>> d = dict(); d # Создаем пустой словарь

{}

>>> d = dict(a=1, b=2); d

{'a': 1, 'b': 2}

>>> d = dict({"a": 1, "b": 2}); d # Словарь

{'a': 1, 'b': 2}

>>> d = dict([("a", 1), ("b", 2)]); d # Список кортежей

{'a': 1, 'b': 2}

>>> d = dict([["a", 1], ["b", 2]]); d # Список списков

{'a': 1, 'b': 2}

 

 

>>> k = ["a", "b"] # Список с ключами

>>> v = [1, 2] # Список со значениями

>>> list(zip(k, v)) # Создание списка кортежей

[('a', 1), ('b', 2)]

>>> d = dict(zip(k, v)); d # Создание словаря

{'a': 1, 'b': 2}

 

 

>>> d = {}; d # Создание пустого словаря

{}

>>> d = { "a": 1, "b": 2 }; d

{'a': 1, 'b': 2}

 

 

>>> d = {} # Создаем пустой словарь

>>> d["a"] = 1 # Добавляем элемент1 (ключ "a")

>>> d["b"] = 2 # Добавляем элемент2 (ключ "b")

>>> d

{'a': 1, 'b': 2}

 

 

>>> d = dict.fromkeys(["a", "b", "c"])

>>> d

{'a': None, 'c': None, 'b': None}

>>> d = dict.fromkeys(["a", "b", "c"], 0) # Указан список

>>> d

{'a': 0, 'c': 0, 'b': 0}

>>> d = dict.fromkeys(("a", "b", "c"), 0) # Указан кортеж

>>> d

{'a': 0, 'c': 0, 'b': 0}

 

 

>>> d1 = d2 = { "a": 1, "b": 2 } # Якобы создали два объекта

>>> d2["b"] = 10

>>> d1, d2 # Изменилось значение в двух переменных!!!

({'a': 1, 'b': 10}, {'a': 1, 'b': 10})

 

 

>>> d1, d2 = { "a": 1, "b": 2 }, { "a": 1, "b": 2 }

>>> d2["b"] = 10

>>> d1, d2

({'a': 1, 'b': 2}, {'a': 1, 'b': 10})

 

Листинг 9.1. Создание поверхностной копии словаря с помощью функции dict()

>>> d1 = { "a": 1, "b": 2 } # Создаем словарь

>>> d2 = dict(d1) # Создаем поверхностную копию

>>> d1 is d2 # Оператор показывает, что это разные объекты

False

>>> d2["b"] = 10

>>> d1, d2 # Изменилось только значение в переменной d2

({'a': 1, 'b': 2}, {'a': 1, 'b': 10})

 

Листинг 9.2. Создание поверхностной копии словаря с помощью метода copy()

>>> d1 = { "a": 1, "b": 2 } # Создаем словарь

>>> d2 = d1.copy() # Создаем поверхностную копию

>>> d1 is d2 # Оператор показывает, что это разные объекты

False

>>> d2["b"] = 10

>>> d1, d2 # Изменилось только значение в переменной d2

({'a': 1, 'b': 2}, {'a': 1, 'b': 10})

 

Листинг 9.3. Создание полной копии словаря

>>> d1 = { "a": 1, "b": [20, 30, 40] }

>>> d2 = dict(d1) # Создаем поверхностную копию

>>> d2["b"][0] = "test"

>>> d1, d2 # Изменились значения в двух переменных!!!

({'a': 1, 'b': ['test', 30, 40]}, {'a': 1, 'b': ['test', 30, 40]})

>>> import copy

>>> d3 = copy.deepcopy(d1) # Создаем полную копию

>>> d3["b"][1] = 800

>>> d1, d3 # Изменилось значение только в переменной d3

({'a': 1, 'b': ['test', 30, 40]}, {'a': 1, 'b': ['test', 800, 40]})

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

>>> d = { 1: "int", "a": "str", (1, 2): "tuple" }

>>> d[1], d["a"], d[(1, 2)]

('int', 'str', 'tuple')

 

 

>>> d = { "a": 1, "b": 2 }

>>> d["c"] # Обращение к несуществующему элементу

Traceback (most recent call last):

File "<pyshell#49>", line 1, in <module>

d["c"] # Обращение к несуществующему элементу

KeyError: 'c'

 

 

>>> d = { "a": 1, "b": 2 }

>>> "a" in d # Ключ существует

True

>>> "c" in d # Ключ не существует

False

 

 

>>> d = { "a": 1, "b": 2 }

>>> "c" not in d # Ключ не существует

True

>>> "a" not in d # Ключ существует

False

 

 

>>> d = { "a": 1, "b": 2 }

>>> d.get("a"), d.get("c"), d.get("c", 800)

(1, None, 800)

 

 

>>> d = { "a": 1, "b": 2 }

>>> d.setdefault("a"), d.setdefault("c"), d.setdefault("d", 0)

(1, None, 0)

>>> d

{'a': 1, 'c': None, 'b': 2, 'd': 0}

 

 

>>> d = { "a": 1, "b": 2 }

>>> d["a"] = 800 # Изменение элемента по ключу

>>> d["c"] = "string" # Будет добавлен новый элемент

>>> d

{'a': 800, 'c': 'string', 'b': 2}

 

 

>>> d = { "a": 1, "b": 2 }

>>> len(d) # Получаем количество ключей в словаре

 

 

>>> d = { "a": 1, "b": 2 }

>>> del d["b"]; d # Удаляем элемент с ключом "b" и выводим словарь

{'a': 1}

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

Листинг 9.4. Перебор элементов словаря

d = {"x": 1, "y": 2, "z": 3}

for key in d.keys(): # Использование метода keys()

print("({0} => {1})".format(key, d[key]), end=" ")

# Выведет: (y => 2) (x => 1) (z => 3)

print() # Вставляем символ перевода строки

for key in d: # Словари также поддерживают итерации

print("({0} => {1})".format(key, d[key]), end=" ")

# Выведет: (y => 2) (x => 1) (z => 3)

 

 

d = {"x": 1, "y": 2, "z": 3}

k = list(d.keys()) # Получаем список ключей

k.sort() # Сортируем список ключей

for key in k:

print("({0} => {1})".format(key, d[key]), end=" ")

# Выведет: (x => 1) (y => 2) (z => 3)

 

 

d = {"x": 1, "y": 2, "z": 3}

for key in sorted(d.keys()):

print("({0} => {1})".format(key, d[key]), end=" ")

# Выведет: (x => 1) (y => 2) (z => 3)

 

 

d = {"x": 1, "y": 2, "z": 3}

for key in sorted(d):

print("({0} => {1})".format(key, d[key]), end=" ")

# Выведет: (x => 1) (y => 2) (z => 3)