В Python просто генераторы и генераторы списков - разные вещи. Здесь есть проблема перевода с английского. То, что мы привыкли называть генератором списка, в английском варианте звучит как "list comprehension " и к генераторам никакого отношения не имеет.
Слово "comprehension" (понимание, осмысление) оказывается как бы не в тему при переводе на русский. Получается что-то вроде "понимание списка". Поэтому мы говорим "генератор списка", понимая под словом "генератор" не объект, а синтаксическую конструкцию, которая генерирует, то есть создает, список.
С другой стороны, объекты-генераторы - это особые объекты-функции, которые между вызовами сохраняют свое состояние. В цикле for они ведут себя подобно итерируемым объектам, к которым относятся списки, словари, строки и др. Однако генераторы поддерживают метод __next__(), а значит являются разновидностью итераторов.
Быстрым способом создания относительно простых объектов-генераторов являются генераторные выражения - generator expressions . Синтаксис этих выражений похож на синтаксис генераторов списков. Однако они возвращают разные типы объектов. Первый - объект-генератор. Второй - список.
Сначала рассмотрим генераторы списков, чтобы привыкнуть к синтаксической конструкции.
Генераторы списков
В Python генераторы списков позволяют создавать и быстро заполнять списки.
Синтаксическая конструкция генератора списка предполагает наличие итерируемого объекта или итератора, на базе которого будет создаваться новый список, а также выражение, которое будет что-то делать с извлеченными из последовательности элементами перед тем как добавить их в формируемый список.
>>> a = [ 1 , 2 , 3 ] >>> b = [ i+10 for i in a] >>> a [ 1 , 2 , 3 ] >>> b [ 11 , 12 , 13 ]
В примере выше генератором списка является выражение . Здесь a - итерируемый объект. В данном случае это другой список. Из него извлекается каждый элемент в цикле for. Перед for описывается действие, которое выполняется над элементом перед его добавлением в новый список.
Обратите внимание, что генератор создает новый список, а не изменяет существующий. Если надо изменить текущую переменную, ей надо присвоить новое значение:
>>> a = [ 1 , 2 , 3 ] >>> a = [ i+10 for i in a] >>> a [ 11 , 12 , 13 ]
Генераторы списков относятся к разряду "синтаксического сахара" языка программирования Python. Другими словами, без них можно обойтись:
>>> for index, value in enumerate (a) : ... a [ index] = value + 10 ... >>> a [ 11 , 12 , 13 ]
Если в программе может быть несколько ссылок на список, генераторами надо пользоваться осторожно:
>>> ls0 = [ 1 , 2 , 3 ] >>> ls1 = ls0 >>> ls1.append (4 ) >>> ls0 [ 1 , 2 , 3 , 4 ] >>> ls1 = [ i+1 for i in ls1] >>> ls1 [ 2 , 3 , 4 , 5 ] >>> ls0 [ 1 , 2 , 3 , 4 ]
Здесь мы предполагаем, что изменение списка через одну переменную, будут видны через другую. Однако если изменить список генератором, то переменные будут указывать на разные списки.
Перебираемым в цикле for объектом может быть быть не только список. В примере ниже в список помещаются строки файла.
>>> lines = [ line.strip () for line in open ("text.txt" ) ] >>> lines [ "one" , "two" , "three" ]
В генератор списка можно добавить условие:
>>> from random import randint >>> nums = [ randint(10 , 20 ) for i in range (10 ) ] >>> nums [ 18 , 17 , 11 , 11 , 15 , 18 , 11 , 20 , 10 , 19 ] >>> nums = [ i for i in nums if i%2 == 0 ] >>> nums [ 18 , 18 , 20 , 10 ]
Генераторы списков могут содержать вложенные циклы:
>>> a = "12" >>> b = "3" >>> c = "456" >>> comb = [ i+j+k for i in a for j in b for k in c] >>> comb [ "134" , "135" , "136" , "234" , "235" , "236" ]
Генераторы словарей и множеств
Если в выражении генератора списка заменить квадратные скобки на фигурные, то можно получить не список, а словарь:
>>> a = { i:i**2 for i in range (11 , 15 ) } >>> a { 11 : 121 , 12 : 144 , 13 : 169 , 14 : 196 }
При этом синтаксис выражения до for должен быть соответствующий словарю, то есть включать ключ и через двоеточие значение. Если этого нет, будет сгенерировано множество:
>>> a = { i for i in range (11 , 15 ) } >>> a set ([ 11 , 12 , 13 , 14 ] ) >>> b = { 1 , 2 , 3 } >>> b set ([ 1 , 2 , 3 ] )
Генераторы
Выражения, создающие объекты-генераторы, похожи на выражения, генерирующие списки, словари и множества за одним исключением. Чтобы создать генераторный объект, надо использовать круглые скобки:
>>> a = (i for i in range (2 , 8 ) ) >>> a < generator object < genexpr> at 0x7efc88787910 > >>> for i in a: ... print (i) ... 2 3 4 5 6 7
Второй раз перебрать генератор в цикле for не получится, так как объект-генератор уже сгенерировал все значения по заложенной в него "формуле". Поэтому генераторы обычно используются, когда надо единожды пройтись по итерируемому объекту.
Кроме того, генераторы экономят память, так как в ней хранятся не все значения, скажем, большого списка, а только предыдущий элемент, предел и формула, по которой вычисляется следующий элемент.
Выражение, создающее генератор, это сокращенная запись следующего:
>>> def func(start, finish) : ... while start < finish: ... yield start * 0.33 ... start += 1 ... >>> a = func(1 , 4 ) >>> a < generator object func at 0x7efc88787a50 > >>> for i in a: ... print (i) ... 0.33 0.66 0.99
Если нет необходимости использовать функцию многократно, проще использовать выражение:
>>> b = (i*0.33 for i in range (1 , 4 ) ) >>> b < generator object < genexpr> at 0x7efc88787960 > >>> for i in b: ... print (i) ... 0.33 0.66 0.99
Представим себе ситуацию - вам необходимо извлечь все элементы списка и присвоить каждый из них своей определенной переменной. Например, у нас есть список описывающий человека и содержащий следующие элементы:
Person_data = ["John", "Smith", 23, "programmer"]
User_name, user_surname, user_age, user_occupation = person_data
После этого мы сможем использовать отдельно каждую созданную переменную.
Обратите внимание, что количество создаваемых переменных должно соответствовать количеству элементов в списке, иначе вы получите ошибку.
Как пользоваться генераторами в Python.
Генераторами списков в Python называются однострочные конструкции, которые позволяют создавать новые списки.
Синтаксис генераторов списков такой:
# самый простой генератор new_list =
В итоге new_list будет содержать числа от 0 до 9. Понятно, что для того чтобы создать такой список незачем пользоваться генератором. Достаточно просто воспользоваться функцией range()
# пример посложнее word = "hello" new_list =
Теперь new_list будет выглядеть так:
["h","e","l","l","o"]
Так же в генераторы списков можно вставлять конструкцию if:
# Создаем список из чисел кратных трем new_list =
В итоге получим:
Наконец, в генераторе можно использовать несколько списков и переменных:
# создание колоды карт при помощи генератора списков # масти suits = "HDCS" # ранги ranks = "23456789TJQKA" # генерируем колоду deck =
Получим следующий результат:
Представьте, сколько времени мы сэкономили, написав всего одну строчку вместо нескольких циклов .
Как извлечь элементы из подсписков в Python.
Так же, часто возникает ситуация, когда необходимо извлечь элементы из подспиков списка.
Например имеем такой список:
Outer = [, , ]
Задача создать отдельный список содержащий все элементы подсписков данного списка. Выполнить эту задачу можно при помощи все того же генератора списков:
New_list =
Таким образом получаем список со всеми элементами:
На этом на сегодня все. Удачи в освоении Python !
Do you know the difference between the following syntax?
(x for x in range(5))
tuple(range(5))
Let’s check it
4 Facts About the Lists
First off, a short review on the lists (arrays in other languages).
- list is a type of data that can be represented as a collection of elements. Simple list looks like this –
- lists take all possible types of data and combinations of data as their components:
- lists can be indexed. You can get access to any individual element or group of elements using the following syntax:
- lists are mutable in Python. This means you can replace, add or remove elements.
What is List Comprehension?
Often seen as a part of functional programming in Python, list comprehensions allow you to create lists with a for loop with less code.
Let’s look at the following example.
You create a list using a for loop and a range() function.
& >>> my_list = >>> for x in range(10): ... my_list.append(x * 2) ... >>> print(my_list)
And this is how the implementation of the previous example is performed using a list comprehension:
>>> comp_list = >>> print(comp_list)
The above example is oversimplified to get the idea of syntax. The same result may be achieved simply using list(range(0, 19, 2)) function. However, you can use a more complex modifier in the first part of comprehension or add a condition that will filter the list. Something like this:
>>> comp_list = >>> print(comp_list)
Another available option is to use list comprehension to combine several lists and create a list of lists. At first glance, the syntax seems to be complicated. It may help to think of lists as an outer and inner sequences.
It’s time to show the power of list comprehensions when you want to create a list of lists by combining two existing lists.
>>> nums = >>> letters = ["A", "B", "C", "D", "E"] >>> nums_letters = [ for n in nums for l in letters] #the comprehensions list combines two simple lists in a complex list of lists. >>> print(nums_letters) >>> print(nums_letters) [, , , , , , , , , , , , , , , , , , , , , , , , ] >>>
Let’s try it with text or it’s correct to say string object.
>>> iter_string = "some text" >>> comp_list = >>> print(comp_list) ["s", "o", "m", "e", "t", "e", "x", "t"]
The comprehensions are not limited to lists. You can create dicts and sets comprehensions as well.
>>> dict_comp = {x:chr(65+x) for x in range(1, 11)}
>>> type(dict_comp)
Difference Between Iterable and Iterator
It will be easier to understand the concept of generators if you get the idea of iterables and iterators.
Iterable is a “sequence” of data, you can iterate over using a loop. The easiest visible example of iterable can be a list of integers – . However, it’s possible to iterate over other types of data like strings, dicts, tuples, sets, etc.
Basically, any object that has iter () method can be used as an iterable. You can check it using hasattr() function in the interpreter.
>>> hasattr(str, "__iter__") True >>> hasattr(bool, "__iter__") False
Iterator protocol is implemented whenever you iterate over a sequence of data. For example, when you use a for loop the following is happening on a background:
- first iter () method is called on the object to converts it to an iterator object.
- next () method is called on the iterator object to get the next element of the sequence.
- StopIteration exception is raised when there are no elements left to call.
Generator Expressions
In Python, generators provide a convenient way to implement the iterator protocol. Generator is an iterable created using a function with a yield statement.
The main feature of generator is evaluating the elements on demand. When you call a normal function with a return statement the function is terminated whenever it encounters a return statement. In a function with a yield statement the state of the function is “saved” from the last call and can be picked up the next time you call a generator function.
>>> def my_gen(): ... for x in range(5): ... yield x
Generator expression allows creating a generator on a fly without a yield keyword. However, it doesn’t share the whole power of generator created with a yield function. The syntax and concept is similar to list comprehensions:
>>> gen_exp = (x ** 2 for x in range(10) if x % 2 == 0) >>> for x in gen_exp: ... print(x) 0 4 16 36 64
In terms of syntax, the only difference is that you use parentheses instead of square brackets. However, the type of data returned by list comprehensions and generator expressions differs.
>>> list_comp =
>>> gen_exp = (x ** 2 for x in range(10) if x % 2 == 0)
>>> print(list_comp)
>>> print(gen_exp)
The main advantage of generator over a list is that it takes much less memory. We can check how much memory is taken by both types using sys.getsizeof() method.
Note: in Python 2 using range() function can’t actually reflect the advantage in term of size, as it still keeps the whole list of elements in memory. In Python 3, however, this example is viable as the range() returns a range object.
>>> from sys import getsizeof >>> my_comp = >>> my_gen = (x * 5 for x in range(1000)) >>> getsizeof(my_comp) 9024 >>> getsizeof(my_gen) 88
We can see this difference because while `list` creating Python reserves memory for the whole list and calculates it on the spot. In case of generator, we receive only ”algorithm”/ “instructions” how to calculate that Python stores. And each time we call for generator, it will only “generate” the next element of the sequence on demand according to “instructions”.
On the other hand, generator will be slower, as every time the element of sequence is calculated and yielded, function context/state has to be saved to be picked up next time for generating next value. That “saving and loading function context/state” takes time.
Final Thoughts
The very first thing that might scare or discourage a newbie programmer is the scale of educational material. The trick here is to treat each concept as an option offered by language, you’re not expected to learn all the language concepts and modules all at once. There are always different ways to solve the same task. Take it as one more tool to get the job done.
У языка программирования Pyrhon есть особая синтаксическая конструкция, с помощью которой можно на основании определенных правил создавать заполненные списки. Формируемые списки могут получаться различными, содержание конструкции может быть разным, поэтому они получили название генераторы списков. Они удобны, потому что записи получаются не такими длинными, нежели при традиционном методе создания списков.
К примеру, нужен список из натуральных чисел до конкретного числа. Традиционный метод будет иметь такой вид:
>>> a = >>> for i in range(1,15): ... a.append(i) ... >>>Список занял три строчки кода. А генератору нужна только одна:
>>> a = >>> aКонструкция – это генератор списка. Всю конструкции нужно поместить в квадратные списки, что отражает создание списка. Внутри скобок есть три части:
- Что будем делать с элементов (в нашей ситуации не делаем ничего, просто вносим в перечень).
- Что будем брать (мы берем элемент i).
- Откуда будем брать (из объекта range). Для отделения частей используем ключевые слова in и for.
Разберем на примере
>>> a = >>> b = >>> bВ этой ситуации мы берем каждый элемент перечня и возводим в квадрат. Отсюда:
- Делаем – возводим наш элемент в квадрат.
- Берем – элемент.
- Откуда – из перечня а.
Тут берем ключ в словаре, а в генерируемый список попадает произведение ключа на имеющееся у него значение.
>>> a = {1:10, 2:20, 3:30} >>> b = [] for i in a] >>> b [, , ] >>> c = >>> cВ данном случае список b содержит вложенные списки. Опустив в генераторе квадратные скобы по выражению ] была бы получена ошибка. Если вам нужен одноуровневый перечень с ключами из словарных значений, нужно взять каждый вложенный перечень и уже оттуда брать каждый компонент. Делается это вложенной конструкцией for. Традиционный синтаксис формирования перечня имеет такой вид:
>>> c = >>> for i in b: ... for j in i: ... c.append(j) ... >>> cГенераторы списков могут дополняться конструкцией if. К примеру, нужно извлечь все числа из строки:
>>> a = "lsj94ksd231 9" >>> b =Либо наполнить список цифрами, кратными 31 или 30:
>>> a = >>> aПеречни так создаваться намного проще и быстрее. Но, они не годятся для замены достаточно сложных конструкций. К примеру, если в условии проверки будет ветка else.
Закончились деньги, а до зарплаты еще пара недель? Можно одолжить, но что делать если не у кого? Не идти же в банк за кредитом. В этом случае вам помогут микрозаймы . Простой зайдите на сайт, оформите заявку (это очень просто и быстро) и через несколько минут вы получите деньги! Очень удобно и быстро, и главное не нужно ни у кого просить!
В языке программирования Python существует специальная синтаксическая конструкция, которая позволяет по определенным правилам создавать заполненные списки. Такие конструкции называются генераторами списков . Их удобство заключается в более короткой записи программного кода, чем если бы создавался список обычным способом.
Например, надо создать список, заполненный натуральными числами до определенного числа. "Классический" способ будет выглядеть примерно так:
>>> a = >>> for i in range (1 , 15 ) : ... a.append (i) ... >>> a
На создание списка ушло три строчки кода. Генератор же сделает это за одну:
>>> a = [ i for i in range (1 , 15 ) ] >>> a
Здесь конструкция [ i for i in range (1 , 15 ) ] является генератором списка. Вся конструкция заключается в квадратные скобки, что как бы говорит, что будет создан список. Внутри квадратных скобок можно выделить три части: 1) что делаем с элементом (в данном случае ничего не делаем, просто добавляем в список), 2) что берем (в данном случае элемент i), 3) откуда берем (здесь из объекта range). Части отделены друг от друга ключевыми словами for и in .
Рассмотрим такой пример:
>>> a = [ 2 , -2 , 4 , -4 , 7 , 5 ] >>> b = [ i**2 for i in a] >>> b
В данном случае в генераторе списка берется каждый элемент из списка a и возводится в квадрат. Таким образом, 1) что делаем - возводим элемент в квадрат, 2) что берем - элемент, 3) откуда берем - из списка a .
>>> >>> b = [ i*a[ i] for i in a] >>> b
Здесь берется ключ из словаря, а в генерируемый список добавляется произведение ключа на его значение.
>>> a = { 1 :10 , 2 :20 , 3 :30 } >>> b = [ [ i, a[ i] ] for i in a] >>> b [, , ] >>> c = [ j for i in b for j in i] >>> c
В этом примере генерируемый список b состоит из вложенных списков. Если бы в генераторе были опущены квадратные скобки в выражении [ i, a[ i] ] , то произошла бы ошибка. Если все же надо получить одноуровневый список из ключей и значений словаря, надо взять каждый вложенный список и из него взять каждый элемент. Это достигается за счет вложенной конструкции for , что демонстрируется в строчке c = [ j for i in b for j in i] . "Классический" синтаксис для заполнения списка c выглядел бы так:
>>> c = >>> for i in b: ... for j in i: ... c.append (j) ... >>> c
В конец генератора можно добавлять конструкцию if . Например, надо из строки извлечь все цифры:) if i%30 == 0 or i%31 == 0 ] >>> a
Таким образом, генераторы позволяют создавать списки легче и быстрее. Однако заменить ими достаточно сложные конструкции не получится. Например, когда условие проверки должно включать ветку else .