Списки в Python. Углубленный уровень
В каждом языке программирования есть одна такая особенность, сложно устроенная, но специально упрощённая штука. Если вы раньше писали на другом языке, можете и не обратить на это внимания, поскольку ваш старый язык не так сильно упрощал эту штуку (потому что он был занят тем, что сильно упрощал какую-нибудь другую штуку). В этой главе вы изучите генераторы списков, словарей и множеств - три взаимосвязанные концепции, сконцентрированные вокруг одной очень мощной технологии. Но сначала я хочу немного отклониться от нашего повествования, чтобы рассказать вам о двух модулях, которые помогут вам передвигаться по вашей локальной файловой системе.
Работа с файлами и каталогами
Python 3 поставляется с модулем os , что означает «операционная система». содержит множество функций для получения информации о локальных каталогах, файлах, процессах и переменных окружения (а в некоторых случаях, и для манипулирования ими). Python предлагает очень хороший унифицированный программный интерфейс для всех поддерживаемых операционных систем , так что ваши программы можно запускать на любом компьютере с минимальным количеством платформо-зависимого кода.
Текущий рабочий каталог
Когда ваше знакомство с Python только начинается, вы много времени проводите в интерактивной оболочке Python . На протяжении всей этой книги вы будете видеть примеры, выглядящие следующим образом:
- Импортирование какого-либо модуля из папки примеров
- Вызов функции из этого модуля
- Объяснение результата
Всегда есть текущий рабочий каталог.
Если вы ничего не знаете о текущем рабочем каталоге, то, возможно, шаг 1 окажется неудачным и будет порождено исключение типа ImportError . Почему? Потому что Python будет искать указанный модуль в пути поиска оператора import , но не найдёт его, потому что каталог examples не содержится в путях поиска. Чтобы исправить это, вы можете сделать одно из двух:
- либо добавить папку examples в путь поиска оператора import ;
- либо сделать текущим рабочим каталогом папку examples .
Текущий рабочий каталог является неявным параметром, который Python постоянно хранит в памяти. Текущий рабочий каталог есть всегда, когда вы работаете в интерактивной оболочке Python, запускаете свой сценарии из командной строки или CGI -сценарий где-то на веб-сервере .
Модуль os содержит две функции для работы с текущим рабочим каталогом.
|
>>> import os |
|
|
>>>
print
(os
.getcwd
()
)
|
|
|
>>> os .chdir () |
|
|
>>>
print
(os
.getcwd
()
)
|
Работа с именами файлов и каталогов
Раз зашла речь о каталогах, я хочу обратить ваше внимание на модуль os .path . Он содержит функции для работы с именами файлов и каталогов.
|
>>> import os |
|
|
>>>
print
(os
.path
.join
("/Users/pilgrim/diveintopython3/examples/"
,
"humansize.py"
)
)
|
|
|
>>>
print
(os
.path
.join
("/Users/pilgrim/diveintopython3/examples"
,
"humansize.py"
)
)
|
|
|
>>>
print
(os
.path
.expanduser
("~"
)
)
|
|
|
>>>
print
(os
.path
.join
(os
.path
.expanduser
("~"
)
,
"diveintopython3"
,
"examples"
,
"humansize.py"
)
)
|
Модуль os .path также содержит функции для разбиения файловых путей, имён папок и файлов на их составные части.
|
>>> pathname = "/Users/pilgrim/diveintopython3/examples/humansize.py" |
|
|
>>>
os
.path
.split
(pathname)
|
|
|
>>> (dirname, filename) = os .path .split (pathname) |
|
|
>>>
dirname |
|
|
>>>
filename |
|
|
>>>
(shortname,
extension)
=
os
.path
.splitext
(filename)
|
Получение содержимого каталога
Модуль glob понимает символы-джокеры, использующиеся в командных оболочках.
Модуль glob - это ещё один инструмент из стандартной библиотеки Python. Это простой способ программно получить содержимое папки, а также он умеет использовать символы-джокеры , с которыми вы наверняка знакомы, если работали в командной строке.
|
>>>
os
.chdir
("/Users/pilgrim/diveintopython3/"
)
|
|
|
>>>
glob
.glob
("examples/*.xml"
)
|
|
|
>>> os .chdir ("examples/" ) |
|
|
>>>
glob
.glob
("*test*.py"
)
|
Получение сведений о файле
Любая современная операционная система хранит сведения о каждом файле (метаданные): дата создания, дата последней модификации, размер файла и т. д. Python предоставляет единый программный интерфейс для доступа к этим метаданным. Вам не надо открывать файл; всё, что требуется - имя файла.
|
>>> import os |
|
|
>>>
print
(os
.getcwd
()
)
|
|
|
>>> metadata = os .stat ("feed.xml" ) |
|
|
>>>
metadata.st_mtime
|
|
|
>>> import time |
|
|
>>>
time
.localtime
(metadata.st_mtime
)
|
Получение абсолютных путей
В предыдущем разделе функция glob .glob () возвращала список относительных путей. В первом примере пути имели вид "examples\feed.xml" , а во втором относительные пути были даже короче, например, "romantest1.py" . Пока вы остаётесь в текущем рабочем каталоге, по этим относительным путям можно будет открывать файлы или получать их метаданные. Но если вы захотите получить абсолютный путь - то есть тот, который включает все имена каталогов до корневого или до буквы диска, вам понадобится функция os .path .realpath () .
>>>
import
os
>>>
print
(os
.getcwd
()
)
c:\Users\pilgrim\diveintopython3\examples
>>>
print
(os
.path
.realpath
("feed.xml"
)
)
c:\Users\pilgrim\diveintopython3\examples\feed.xml
Генераторы списков
В генераторах списков можно использовать любые выражения Python.
С помощью генераторов списков можно легко отобразить один список в другой, применив некоторую функцию к каждому элементу.
|
>>>
a_list =
[
1
,
9
,
8
,
4
]
|
|
|
>>>
a_list |
|
|
>>>
a_list =
[
elem * 2
for
elem in
a_list]
|
В генераторах списков можно использовать любые выражения Python, включая функции модуля os , применяемые для работы с файлами и каталогами.
|
>>>
import
os
,
glob
|
|
|
>>>
[
os
.path
.realpath
(f)
for
f in
glob
.glob
("*.xml"
)
]
|
При генерировании списков можно также фильтровать элементы, чтобы отбросить некоторые значения.
|
>>> import os , glob |
|
|
>>>
[
f for
f in
glob
.glob
("*.py"
)
if
os
.stat
(f)
.st_size
>
6000
]
|
Все рассмотренные примеры генераторов списков использовали простые выражения: умножение числа на константу, вызов одной функции или просто возврат элемента списка без изменений (после фильтрации). Но при генерации списков можно использовать выражения любой сложности.
|
>>> import os , glob |
|
|
>>>
[
(os
.stat
(f)
.st_size
,
os
.path
.realpath
(f)
)
for
f in
glob
.glob
("*.xml"
)
]
|
|
|
>>>
[
(humansize.approximate_size
(os
.stat
(f)
.st_size
)
,
f)
for
f in
glob
.glob
("*.xml"
)
]
|
Генераторы словарей
Генератор словаря похож на генератор списка, но вместо списка он создает словарь.
|
>>> import os , glob |
|
|
>>> metadata = [ (f, os .stat (f) ) for f in glob .glob ("*test*.py" ) ] |
|
|
>>>
metadata[
0
]
|
|
|
>>> metadata_dict = { f:os .stat (f) for f in glob .glob ("*test*.py" ) } |
|
|
>>>
type
(metadata_dict)
|
|
|
>>>
list
(metadata_dict.keys
()
)
|
|
|
>>>
metadata_dict[
"alphameticstest.py"
]
.st_size
|
Также, как и в генераторах списков, вы можете включать в генераторы словарей условие if , чтобы отфильтровать входную последовательность с помощью выражения-условия, вычисляющегося для каждого элемента.
|
>>> import os , glob , humansize |
List comprehensions (генераторы списков), как это не странно, предназначены для удобной обработки списков, к которой можно отнести и создание новых списков, и модификацию существующих.
Допустим, нам необходимо получить список нечетных чисел, не превышающих 25. В принципе, только познакомившись с работой команды xrange решить эту проблему несложно.
Res = for x in xrange(1, 25, 2): res.append(x) ... print res
В общем-то, полученный результат - целиком нас устраивает всем, кроме длинной записи. Тут-то на помощь и придет наш «сахарок». В самом простом виде, он обычно
Res = ... print res
Синтаксис, в принципе прост. Все выражение записывается в квадратных скобках. Сначала идет выражение, которое будет задавать элементы списка, потом - цикл с помощью которого можно изменять выражение. Обе части могут быть сколь угодно сложными. Например, вот как можно получить список квадратов тех же нечетных чисел.
По желанию, можно добавить дополнительные условия фильтрации. Например, доработаем наш предыдущий пример так, чтобы исключались квадраты чисел, кратных 3.
Res = ... print res
Задание 6.1. Генератор списка
Нужно получить список двоичных чисел не являющихся квадратами.
Генераторы
Конструкции типа mylist = формируют списки элементов, значения которых хранятся в памяти. К ним можно применять конструкцию for i in mylist: print(i) для работы с элементами сколько угодно раз.
Генераторы это тоже итерируемые объекты, но прочитать их можно лишь один раз. Это связано с тем, что они не хранят значения в памяти, а генерируют их на лету:
Mygenerator = (x*x for x in range(3)) for i in mygenerator: print(i)
Всё то же самое, разве что используются круглые скобки вместо квадратных. НО: нельзя применить конструкцию for i in mygenerator второй раз, так как генератор может быть использован только единожды: он вычисляет 0, потом забывает про него и вычисляет 1, завершая вычислением 4 - одно за другим. Также нельзя получить число элементов функцией len() . К генераторам нельзя применить срезы mygenerator . Но, генераторы позволяют сократить объем памяти для запуска программы.
Yield
Yield это ключевое слово, которое используется примерно как return - отличие в том, что функция вернёт генератор.
Def createGenerator() : mylist = range(3) for i in mylist: yield i*i mygenerator = createGenerator() # создаём генератор for i in mygenerator: print(i)
Задание 6.2. Генератор тетраэдрических чисел
При помощи генератора треугольных чисел создать генератор тетраэдрических чисел.
Задание 6.3. Генератор переливаний
Имеется школьная задача о получении нужного объема при помощи бесконечного бассейна и двух ведер. Например: нужно получить 4 литра при помощи двух ведер емкостью 3 и 5 литров. Имеется ее решение методом бильярдного шара .
Необходимо создать генератор, выдающий пары чисел - наполненности сосудов. Пример работы:
Buckets = pool(3,5) for a,b in buckets: print("a=",a," b=",b) if b==4: break
Генераторы и итераторы представляют собой инструменты, которые, как правило, используются для поточной обработки данных. В уроке рассмотрим концепцию итераторов в Python , научимся создавать свои итераторы и разберемся как работать с генераторами.
Итераторы в языке Python
Во многих современных языках программирования используют такие сущности как итераторы. Основное их назначение – это упрощение навигации по элементам объекта, который, как правило, представляет собой некоторую коллекцию (список, словарь и т.п.). Язык Python , в этом случае, не исключение и в нем тоже есть поддержка итераторов. Итератор представляет собой объект перечислитель, который для данного объекта выдает следующий элемент, либо бросает исключение, если элементов больше нет.
Основное место использования итераторов – это цикл for . Если вы перебираете элементы в некотором списке или символы в строке с помощью цикла for , то,фактически, это означает, что при каждой итерации цикла происходит обращение к итератору, содержащемуся в строке/списке, с требованием выдать следующий элемент, если элементов в объекте больше нет, то итератор генерирует исключение, обрабатываемое в рамках цикла for незаметно для пользователя.
Приведем несколько примеров, которые помогут лучше понять эту концепцию. Для начала выведем элементы произвольного списка на экран.
> > > num_list = > > > for i in num_list: print (i) 1 2 3 4 5Как уже было сказано, объекты, элементы которых можно перебирать в цикле for , содержат в себе объект итератор, для того, чтобы его получить необходимо использовать функцию iter() , а для извлечения следующего элемента из итератора – функцию next() .
> > > itr = iter (num_list) > > > print (next(itr)) 1 > > > print (next(itr)) 2 > > > print (next(itr)) 3 > > > print (next(itr)) 4 > > > print (next(itr)) 5 > > > print (next(itr)) Traceback (most recent call last): File "Как видно из приведенного выше примера вызов функции next(itr) каждый раз возвращает следующий элемент из списка, а когда эти элементы заканчиваются, генерируется исключение StopIteration .
Создание собственных итераторов
Если нужно обойти элементы внутри объекта вашего собственного класса, необходимо построить свой итератор. Создадим класс, объект которого будет итератором, выдающим определенное количество единиц, которое пользователь задает при создании объекта. Такой класс будет содержать конструктор, принимающий на вход количество единиц и метод __next__() , без него экземпляры данного класса не будут итераторами.
__init__ < self .limit: self .counter += 1 return 1 else : raise StopIteration s_iter1 = SimpleIterator(3 ) print (next(s_iter1)) print (next(s_iter1)) print (next(s_iter1)) print (next(s_iter1))В нашем примере при четвертом вызове функции next() будет выброшено исключение StopIteration . Если мы хотим, чтобы с данным объектом можно было работать в цикле for , то в класс SimpleIterator нужно добавить метод __iter__() , который возвращает итератор, в данном случае этот метод должен возвращать self .
class SimpleIterator : def __iter__ (self ): return self def __init__ (self , limit ): self .limit = limit self .counter = 0 def __next__ (self ): if self .counter < self .limit: self .counter += 1 return 1 else : raise StopIteration s_iter2 = SimpleIterator(5 ) for i in s_iter2: print (i)Генераторы
Генераторы позволяют значительно упростить работу по конструированию итераторов. В предыдущих примерах, для построения итератора и работы с ним, мы создавали отдельный класс. Генератор – это функция, которая будучи вызванной в функции next() возвращает следующий объект согласно алгоритму ее работы. Вместо ключевого слова return в генераторе используется yield . Проще всего работу генератор посмотреть на примере. Напишем функцию, которая генерирует необходимое нам количество единиц.
def simple_generator (val ): while val > 0 : val -= 1 yield 1 gen_iter = simple_generator(5 ) print (next(gen_iter)) print (next(gen_iter)) print (next(gen_iter)) print (next(gen_iter)) print (next(gen_iter)) print (next(gen_iter))Данная функция будет работать точно также, как класс SimpleIterator из предыдущего примера.
Ключевым моментом для понимания работы генераторов является то, при вызове yield функция не прекращает свою работу, а “замораживается” до очередной итерации, запускаемой функцией next() . Если вы в своем генераторе, где-то используете ключевое слово
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.
В 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
