Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Python paradimal programming: export from Russian Wikipedia (with edits history) for import to Russian Wikibooks
This file has been truncated, but you can view the full file.
<mediawiki xmlns="http://www.mediawiki.org/xml/export-0.10/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.mediawiki.org/xml/export-0.10/ http://www.mediawiki.org/xml/export-0.10.xsd" version="0.10" xml:lang="ru">
<siteinfo>
<sitename>Википедия</sitename>
<dbname>ruwiki</dbname>
<base>https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B3%D0%BB%D0%B0%D0%B2%D0%BD%D0%B0%D1%8F_%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%86%D0%B0</base>
<generator>MediaWiki 1.33.0-wmf.6</generator>
<case>first-letter</case>
<namespaces>
<namespace key="-2" case="first-letter">Медиа</namespace>
<namespace key="-1" case="first-letter">Служебная</namespace>
<namespace key="0" case="first-letter" />
<namespace key="1" case="first-letter">Обсуждение</namespace>
<namespace key="2" case="first-letter">Участник</namespace>
<namespace key="3" case="first-letter">Обсуждение участника</namespace>
<namespace key="4" case="first-letter">Википедия</namespace>
<namespace key="5" case="first-letter">Обсуждение Википедии</namespace>
<namespace key="6" case="first-letter">Файл</namespace>
<namespace key="7" case="first-letter">Обсуждение файла</namespace>
<namespace key="8" case="first-letter">MediaWiki</namespace>
<namespace key="9" case="first-letter">Обсуждение MediaWiki</namespace>
<namespace key="10" case="first-letter">Шаблон</namespace>
<namespace key="11" case="first-letter">Обсуждение шаблона</namespace>
<namespace key="12" case="first-letter">Справка</namespace>
<namespace key="13" case="first-letter">Обсуждение справки</namespace>
<namespace key="14" case="first-letter">Категория</namespace>
<namespace key="15" case="first-letter">Обсуждение категории</namespace>
<namespace key="100" case="first-letter">Портал</namespace>
<namespace key="101" case="first-letter">Обсуждение портала</namespace>
<namespace key="102" case="first-letter">Инкубатор</namespace>
<namespace key="103" case="first-letter">Обсуждение Инкубатора</namespace>
<namespace key="104" case="first-letter">Проект</namespace>
<namespace key="105" case="first-letter">Обсуждение проекта</namespace>
<namespace key="106" case="first-letter">Арбитраж</namespace>
<namespace key="107" case="first-letter">Обсуждение арбитража</namespace>
<namespace key="828" case="first-letter">Модуль</namespace>
<namespace key="829" case="first-letter">Обсуждение модуля</namespace>
<namespace key="2300" case="first-letter">Гаджет</namespace>
<namespace key="2301" case="first-letter">Обсуждение гаджета</namespace>
<namespace key="2302" case="case-sensitive">Определение гаджета</namespace>
<namespace key="2303" case="case-sensitive">Обсуждение определения гаджета</namespace>
<namespace key="2600" case="first-letter">Тема</namespace>
</namespaces>
</siteinfo>
<page>
<title>Функциональное программирование на Python</title>
<ns>0</ns>
<id>512957</id>
<revision>
<id>3162691</id>
<timestamp>2007-02-09T18:11:15Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>Новая: Списочные выражения (''list comprehension'') — наиболее выразительное из функциональных средств Питона. Наприм...</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="2523">Списочные выражения (''list comprehension'') — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
Определить функцию можно с помощью [[лямбда-исчисление|лямбда-выражения]] и тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям. Например, в функции-фильтре:
&gt;&gt;&gt; somelist = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, somelist)
[4, 2, -1]
Следует отметить, что того же результата можно добиться с помощью спискового выражения &lt;code&gt;[x for x in somelist if x&lt;5]&lt;/code&gt;.
В Питон есть и другие подобные функции, одним из аргументом которых являются функции: map(), reduce(), apply().
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
# ^- это строка документации
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3</text>
<sha1>gbfxd2cltgrng36918gdr7y7x1tmxim</sha1>
</revision>
<revision>
<id>3162747</id>
<parentid>3162691</parentid>
<timestamp>2007-02-09T18:16:32Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="3858">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: возможность передачи функции в качестве агрумента и возврат функции в качестве значения из функции, развитые средства обработки списков, рекурсия. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'') — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Определить функцию можно с помощью [[лямбда-исчисление|лямбда-выражения]] и тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям. Например, в функции-фильтре:
&gt;&gt;&gt; somelist = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, somelist)
[4, 2, -1]
Следует отметить, что того же результата можно добиться с помощью спискового выражения &lt;code&gt;[x for x in somelist if x&lt;5]&lt;/code&gt;.
В Питон есть и другие подобные функции, одним из аргументом которых являются функции: map(), reduce(), apply().
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
# ^- это строка документации
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
== Ссылки ==
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>a2uy8auvpqh2pgqph9t0agzhbbjpm5a</sha1>
</revision>
<revision>
<id>3162754</id>
<parentid>3162747</parentid>
<timestamp>2007-02-09T18:17:30Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>/* Списочные выражения */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="3950">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: возможность передачи функции в качестве агрумента и возврат функции в качестве значения из функции, развитые средства обработки списков, рекурсия. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Определить функцию можно с помощью [[лямбда-исчисление|лямбда-выражения]] и тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям. Например, в функции-фильтре:
&gt;&gt;&gt; somelist = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, somelist)
[4, 2, -1]
Следует отметить, что того же результата можно добиться с помощью спискового выражения &lt;code&gt;[x for x in somelist if x&lt;5]&lt;/code&gt;.
В Питон есть и другие подобные функции, одним из аргументом которых являются функции: map(), reduce(), apply().
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
# ^- это строка документации
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
== Ссылки ==
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>66q34iccs5044ya731iu4rtku8qm1rw</sha1>
</revision>
<revision>
<id>3167582</id>
<parentid>3162754</parentid>
<timestamp>2007-02-10T07:42:59Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="4191">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: возможность передачи функции в качестве агрумента и возврат функции в качестве значения из функции, развитые средства обработки списков, рекурсия. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Определить функцию можно с помощью [[лямбда-исчисление|лямбда-выражения]] и тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям. Например, в функции-фильтре:
&gt;&gt;&gt; somelist = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, somelist)
[4, 2, -1]
Следует отметить, что того же результата можно добиться с помощью спискового выражения &lt;code&gt;[x for x in somelist if x&lt;5]&lt;/code&gt;.
В Питон есть и другие подобные функции, одним из аргументом которых являются функции: map(), reduce(), apply().
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
# ^- это строка документации
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>0k0gqeol4mkcv6dzm8d2397s889vcxe</sha1>
</revision>
<revision>
<id>3167637</id>
<parentid>3167582</parentid>
<timestamp>2007-02-10T07:52:56Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<comment>/* Возможности */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="4877">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: возможность передачи функции в качестве агрумента и возврат функции в качестве значения из функции, развитые средства обработки списков, рекурсия. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Определить функцию можно с помощью [[лямбда-исчисление|лямбда-выражения]] и тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям. Например, в функции-фильтре:
&gt;&gt;&gt; somelist = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, somelist)
[4, 2, -1]
Следует отметить, что того же результата можно добиться с помощью спискового выражения &lt;code&gt;[x for x in somelist if x&lt;5]&lt;/code&gt;.
В Питон есть и другие подобные функции, одним из аргументом которых являются функции: map(), reduce(), apply().
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
# ^- это строка документации
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений
* генераторные выражения
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>jecrmsn1wetopuqrcy5xh3qha6uonmx</sha1>
</revision>
<revision>
<id>3167659</id>
<parentid>3167637</parentid>
<timestamp>2007-02-10T07:57:25Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="5104">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: возможность передачи функции в качестве агрумента и возврат функции в качестве значения из функции, развитые средства обработки списков, рекурсия. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Определить функцию можно с помощью [[лямбда-исчисление|лямбда-выражения]] и тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям. Например, в функции-фильтре:
&gt;&gt;&gt; somelist = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, somelist)
[4, 2, -1]
Следует отметить, что того же результата можно добиться с помощью спискового выражения &lt;code&gt;[x for x in somelist if x&lt;5]&lt;/code&gt;.
В Питон есть и другие подобные функции, одним из аргументом которых являются функции: map(), reduce(), apply().
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
# ^- это строка документации
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений &lt;ref name="recipe 363602"&gt; [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/363602 Рецепт из книги Python Cookbook]&lt;/ref&gt;,
&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* генераторные выражения
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>2bwt86ney3kjgqr061q7yx5ay78f9ke</sha1>
</revision>
<revision>
<id>3167660</id>
<parentid>3167659</parentid>
<timestamp>2007-02-10T07:57:40Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<comment>/* Ленивые вычисления */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="5103">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: возможность передачи функции в качестве агрумента и возврат функции в качестве значения из функции, развитые средства обработки списков, рекурсия. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Определить функцию можно с помощью [[лямбда-исчисление|лямбда-выражения]] и тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям. Например, в функции-фильтре:
&gt;&gt;&gt; somelist = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, somelist)
[4, 2, -1]
Следует отметить, что того же результата можно добиться с помощью спискового выражения &lt;code&gt;[x for x in somelist if x&lt;5]&lt;/code&gt;.
В Питон есть и другие подобные функции, одним из аргументом которых являются функции: map(), reduce(), apply().
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
# ^- это строка документации
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений &lt;ref name="recipe 363602"&gt; [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/363602 Рецепт из книги Python Cookbook]&lt;/ref&gt;,&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* генераторные выражения
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>h3uzolfm894p0fkqkqpt9vbuovatavt</sha1>
</revision>
<revision>
<id>3167676</id>
<parentid>3167660</parentid>
<timestamp>2007-02-10T08:00:55Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<comment>/* Ленивые вычисления */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="5360">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: возможность передачи функции в качестве агрумента и возврат функции в качестве значения из функции, развитые средства обработки списков, рекурсия. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Определить функцию можно с помощью [[лямбда-исчисление|лямбда-выражения]] и тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям. Например, в функции-фильтре:
&gt;&gt;&gt; somelist = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, somelist)
[4, 2, -1]
Следует отметить, что того же результата можно добиться с помощью спискового выражения &lt;code&gt;[x for x in somelist if x&lt;5]&lt;/code&gt;.
В Питон есть и другие подобные функции, одним из аргументом которых являются функции: map(), reduce(), apply().
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
# ^- это строка документации
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* генераторные выражения
Некоторые примеры из книги рецептов:
* [[http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]]
* [[http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]]
* [[http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>qwjqwrzr90wr2plarfym5i88bazwp1d</sha1>
</revision>
<revision>
<id>3167679</id>
<parentid>3167676</parentid>
<timestamp>2007-02-10T08:01:13Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<comment>/* Ленивые вычисления */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="5354">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: возможность передачи функции в качестве агрумента и возврат функции в качестве значения из функции, развитые средства обработки списков, рекурсия. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Определить функцию можно с помощью [[лямбда-исчисление|лямбда-выражения]] и тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям. Например, в функции-фильтре:
&gt;&gt;&gt; somelist = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, somelist)
[4, 2, -1]
Следует отметить, что того же результата можно добиться с помощью спискового выражения &lt;code&gt;[x for x in somelist if x&lt;5]&lt;/code&gt;.
В Питон есть и другие подобные функции, одним из аргументом которых являются функции: map(), reduce(), apply().
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
# ^- это строка документации
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* генераторные выражения
Некоторые примеры из книги рецептов:
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>emrfj598ed3v2dxq86krat4wqj021qd</sha1>
</revision>
<revision>
<id>3167690</id>
<parentid>3167679</parentid>
<timestamp>2007-02-10T08:02:35Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<comment>/* Ленивые вычисления */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="5386">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: возможность передачи функции в качестве агрумента и возврат функции в качестве значения из функции, развитые средства обработки списков, рекурсия. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Определить функцию можно с помощью [[лямбда-исчисление|лямбда-выражения]] и тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям. Например, в функции-фильтре:
&gt;&gt;&gt; somelist = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, somelist)
[4, 2, -1]
Следует отметить, что того же результата можно добиться с помощью спискового выражения &lt;code&gt;[x for x in somelist if x&lt;5]&lt;/code&gt;.
В Питон есть и другие подобные функции, одним из аргументом которых являются функции: map(), reduce(), apply().
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
# ^- это строка документации
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* [[Python#Генераторы|генераторные выражения]]
Некоторые примеры из книги рецептов:
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>rccwuewmmfql97rmlmez7fnxa2ny4a4</sha1>
</revision>
<revision>
<id>3167696</id>
<parentid>3167690</parentid>
<timestamp>2007-02-10T08:03:02Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<comment>/* Ленивые вычисления */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="5410">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: возможность передачи функции в качестве агрумента и возврат функции в качестве значения из функции, развитые средства обработки списков, рекурсия. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Определить функцию можно с помощью [[лямбда-исчисление|лямбда-выражения]] и тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям. Например, в функции-фильтре:
&gt;&gt;&gt; somelist = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, somelist)
[4, 2, -1]
Следует отметить, что того же результата можно добиться с помощью спискового выражения &lt;code&gt;[x for x in somelist if x&lt;5]&lt;/code&gt;.
В Питон есть и другие подобные функции, одним из аргументом которых являются функции: map(), reduce(), apply().
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
# ^- это строка документации
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* [[Python#Генераторы|Генераторы и генераторные выражения]]
Некоторые примеры из книги рецептов:
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>le5u7ksyamoejeti8ciq4gzhek8ilu3</sha1>
</revision>
<revision>
<id>3167703</id>
<parentid>3167696</parentid>
<timestamp>2007-02-10T08:04:10Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<comment>/* Замыкания */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="5355">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: возможность передачи функции в качестве агрумента и возврат функции в качестве значения из функции, развитые средства обработки списков, рекурсия. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Определить функцию можно с помощью [[лямбда-исчисление|лямбда-выражения]] и тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям. Например, в функции-фильтре:
&gt;&gt;&gt; somelist = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, somelist)
[4, 2, -1]
Следует отметить, что того же результата можно добиться с помощью спискового выражения &lt;code&gt;[x for x in somelist if x&lt;5]&lt;/code&gt;.
В Питон есть и другие подобные функции, одним из аргументом которых являются функции: map(), reduce(), apply().
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* [[Python#Генераторы|Генераторы и генераторные выражения]]
Некоторые примеры из книги рецептов:
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>q8dv0ej4wqfyl4twyi5lhpe1p1py14p</sha1>
</revision>
<revision>
<id>3167714</id>
<parentid>3167703</parentid>
<timestamp>2007-02-10T08:06:30Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="5348">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: [[Функция высшего порядка|функции высших порядков]], развитые средства обработки списков, рекурсия, возможность организации ленивых вычислений. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Определить функцию можно с помощью [[лямбда-исчисление|лямбда-выражения]] и тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям. Например, в функции-фильтре:
&gt;&gt;&gt; somelist = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, somelist)
[4, 2, -1]
Следует отметить, что того же результата можно добиться с помощью спискового выражения &lt;code&gt;[x for x in somelist if x&lt;5]&lt;/code&gt;.
В Питон есть и другие подобные функции, одним из аргументом которых являются функции: map(), reduce(), apply().
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* [[Python#Генераторы|Генераторы и генераторные выражения]]
Некоторые примеры из книги рецептов:
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>98ygq1x22uh2r7j41ilxvh0t4jp1krr</sha1>
</revision>
<revision>
<id>3167718</id>
<parentid>3167714</parentid>
<timestamp>2007-02-10T08:07:26Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="5411">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: [[Функция высшего порядка|функции высших порядков]], развитые средства обработки списков, [[Рекурсия||рекурсия]], возможность организации [[Ленивые вычисления||ленивых вычислений]]. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Определить функцию можно с помощью [[лямбда-исчисление|лямбда-выражения]] и тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям. Например, в функции-фильтре:
&gt;&gt;&gt; somelist = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, somelist)
[4, 2, -1]
Следует отметить, что того же результата можно добиться с помощью спискового выражения &lt;code&gt;[x for x in somelist if x&lt;5]&lt;/code&gt;.
В Питон есть и другие подобные функции, одним из аргументом которых являются функции: map(), reduce(), apply().
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* [[Python#Генераторы|Генераторы и генераторные выражения]]
Некоторые примеры из книги рецептов:
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>op3cpfpd7dlqthdde8hyhohoq3ko9jn</sha1>
</revision>
<revision>
<id>3167719</id>
<parentid>3167718</parentid>
<timestamp>2007-02-10T08:07:37Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="5410">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: [[Функция высшего порядка|функции высших порядков]], развитые средства обработки списков, [[Рекурсия||рекурсия]], возможность организации [[Ленивые вычисления|ленивых вычислений]]. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Определить функцию можно с помощью [[лямбда-исчисление|лямбда-выражения]] и тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям. Например, в функции-фильтре:
&gt;&gt;&gt; somelist = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, somelist)
[4, 2, -1]
Следует отметить, что того же результата можно добиться с помощью спискового выражения &lt;code&gt;[x for x in somelist if x&lt;5]&lt;/code&gt;.
В Питон есть и другие подобные функции, одним из аргументом которых являются функции: map(), reduce(), apply().
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* [[Python#Генераторы|Генераторы и генераторные выражения]]
Некоторые примеры из книги рецептов:
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>gvk3vgjtlcw79ocytb0ozp85d0i9rf5</sha1>
</revision>
<revision>
<id>3167723</id>
<parentid>3167719</parentid>
<timestamp>2007-02-10T08:07:52Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="5409">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: [[Функция высшего порядка|функции высших порядков]], развитые средства обработки списков, [[Рекурсия|рекурсия]], возможность организации [[Ленивые вычисления|ленивых вычислений]]. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Определить функцию можно с помощью [[лямбда-исчисление|лямбда-выражения]] и тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям. Например, в функции-фильтре:
&gt;&gt;&gt; somelist = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, somelist)
[4, 2, -1]
Следует отметить, что того же результата можно добиться с помощью спискового выражения &lt;code&gt;[x for x in somelist if x&lt;5]&lt;/code&gt;.
В Питон есть и другие подобные функции, одним из аргументом которых являются функции: map(), reduce(), apply().
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* [[Python#Генераторы|Генераторы и генераторные выражения]]
Некоторые примеры из книги рецептов:
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>p0t0ytf5ulg6ssreiwwdu1mfqsrfc1p</sha1>
</revision>
<revision>
<id>3167726</id>
<parentid>3167723</parentid>
<timestamp>2007-02-10T08:08:20Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="5462">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: [[Функция высшего порядка|функции высших порядков]], развитые средства обработки списков, [[Рекурсия#Рекурсия в программировании|рекурсия]], возможность организации [[Ленивые вычисления|ленивых вычислений]]. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Определить функцию можно с помощью [[лямбда-исчисление|лямбда-выражения]] и тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям. Например, в функции-фильтре:
&gt;&gt;&gt; somelist = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, somelist)
[4, 2, -1]
Следует отметить, что того же результата можно добиться с помощью спискового выражения &lt;code&gt;[x for x in somelist if x&lt;5]&lt;/code&gt;.
В Питон есть и другие подобные функции, одним из аргументом которых являются функции: map(), reduce(), apply().
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* [[Python#Генераторы|Генераторы и генераторные выражения]]
Некоторые примеры из книги рецептов:
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>d6dj8pxjtolsn880kwoltecau20zgof</sha1>
</revision>
<revision>
<id>3167734</id>
<parentid>3167726</parentid>
<timestamp>2007-02-10T08:09:51Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="5500">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: [[Функция высшего порядка|функции высших порядков]], развитые средства [[Обработка списков|обработки списков]], [[Рекурсия#Рекурсия в программировании|рекурсия]], возможность организации [[Ленивые вычисления|ленивых вычислений]]. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Определить функцию можно с помощью [[лямбда-исчисление|лямбда-выражения]] и тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям. Например, в функции-фильтре:
&gt;&gt;&gt; somelist = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, somelist)
[4, 2, -1]
Следует отметить, что того же результата можно добиться с помощью спискового выражения &lt;code&gt;[x for x in somelist if x&lt;5]&lt;/code&gt;.
В Питон есть и другие подобные функции, одним из аргументом которых являются функции: map(), reduce(), apply().
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* [[Python#Генераторы|Генераторы и генераторные выражения]]
Некоторые примеры из книги рецептов:
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>rn4oq6fyo8lqi1z38dij91pu1gojmin</sha1>
</revision>
<revision>
<id>3167810</id>
<parentid>3167734</parentid>
<timestamp>2007-02-10T08:25:10Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<comment>/* Определение функции */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="6994">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: [[Функция высшего порядка|функции высших порядков]], развитые средства [[Обработка списков|обработки списков]], [[Рекурсия#Рекурсия в программировании|рекурсия]], возможность организации [[Ленивые вычисления|ленивых вычислений]]. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Функция в Питон может быть определена с помощью оператора &lt;code&gt;def&lt;/code&gt; или лямбда-выражением. Следующие выражения эквивалентны:
def func(x, y):
return x**2 + y**2
func = lambda x, y: x**2 + y**2
Определив функцию с помощью [[лямбда-исчисление|лямбда-выражения]], можно тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям.
Следует отметить, что того же результата можно добиться с помощью спискового выражения &lt;code&gt;[x for x in somelist if x&lt;5]&lt;/code&gt;.
В Питон есть и другие подобные функции, одним из аргументом которых являются функции: map(), reduce(), apply().
==== map() ====
Функция &lt;code&gt;map()&lt;/code&gt; позволяет обрабатывать один или несколько последовательностей с помощью заданной функции:
&gt;&gt;&gt; spisok1 = [7, 2, 3, 10, 12]
&gt;&gt;&gt; spisok2 = [-1, 1, -5, 4, 6]
&gt;&gt;&gt; map(lambda x, y: x*y, spisok1, spisok2)
[-7, 2, -15, 40, 72]
Аналогичного (только при одинаковой длине списков) результата можно добиться с помощью списковых выражений:
&gt;&gt;&gt; [x*y for x, y in zip(spisok1, spisok2)]
[-7, 2, -15, 40, 72]
==== filter() ====
Функция &lt;code&gt;filter()&lt;/code&gt; позволяет фильтровать значения последовательности. В результирующем списке только те значения, для которых значение функции для элемента истинно:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, spisok) # В результат попадают только те элементы x, для которых x &lt; 5 истинно
[4, 2, -1]
Тоже самое с помощью списковых выражений:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; [x for x in spisok if x &lt; 5]
[4, 2, -1]
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* [[Python#Генераторы|Генераторы и генераторные выражения]]
Некоторые примеры из книги рецептов:
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>bkcg04ixkh5t4wr6zxzf7akrwjumu8v</sha1>
</revision>
<revision>
<id>3167953</id>
<parentid>3167810</parentid>
<timestamp>2007-02-10T08:49:50Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<comment>/* Возможности */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="8092">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: [[Функция высшего порядка|функции высших порядков]], развитые средства [[Обработка списков|обработки списков]], [[Рекурсия#Рекурсия в программировании|рекурсия]], возможность организации [[Ленивые вычисления|ленивых вычислений]]. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Функция в Питон может быть определена с помощью оператора &lt;code&gt;def&lt;/code&gt; или лямбда-выражением. Следующие выражения эквивалентны:
def func(x, y):
return x**2 + y**2
func = lambda x, y: x**2 + y**2
Определив функцию с помощью [[лямбда-исчисление|лямбда-выражения]], можно тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям.
=== Встроенные функции высших порядков ===
В Питон есть функции, одним из аргументом которых являются другие функции: map(), filter(), reduce(), apply().
==== map() ====
Функция &lt;code&gt;map()&lt;/code&gt; позволяет обрабатывать один или несколько последовательностей с помощью заданной функции:
&gt;&gt;&gt; spisok1 = [7, 2, 3, 10, 12]
&gt;&gt;&gt; spisok2 = [-1, 1, -5, 4, 6]
&gt;&gt;&gt; map(lambda x, y: x*y, spisok1, spisok2)
[-7, 2, -15, 40, 72]
Аналогичного (только при одинаковой длине списков) результата можно добиться с помощью списковых выражений:
&gt;&gt;&gt; [x*y for x, y in zip(spisok1, spisok2)]
[-7, 2, -15, 40, 72]
==== filter() ====
Функция &lt;code&gt;filter()&lt;/code&gt; позволяет фильтровать значения последовательности. В результирующем списке только те значения, для которых значение функции для элемента истинно:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, spisok) # В результат попадают только те элементы x, для которых x &lt; 5 истинно
[4, 2, -1]
Тоже самое с помощью списковых выражений:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; [x for x in spisok if x &lt; 5]
[4, 2, -1]
==== reduce() ====
Для организации цепочечных вычислений в списке можно использовать функцию &lt;code&gt;reduce()&lt;/code&gt;. Например, произведение элементов списка может быть произведено так:
&gt;&gt;&gt; spisok = [1, 2, 3, 4, 5]
&gt;&gt;&gt; reduce(lambda res, x: res*x, spisok, 1)
120
Вычисления происходят в следующем порядке:
((((1*1)*2)*3)*4)*5
Цепочка вызовов связывается с помощью промежуточного результата (&lt;code&gt;res&lt;code/&gt;). Если список пустой, просто используется третий параметр (в случае произведения нуля множителей это 1):
&gt;&gt;&gt; reduce(lambda res, x: res*x, [], 1)
1
Разумеется, промежуточный результат необязательно число. Это может быть любой другой тип данных, в том числе и список. Следующий пример показывает ''реверс'' списка:
&gt;&gt;&gt; reduce(lambda res, x: [x]+res, [1, 2, 3, 4], [])
[4, 3, 2, 1]
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* [[Python#Генераторы|Генераторы и генераторные выражения]]
Некоторые примеры из книги рецептов:
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>ixxjn52tafsgd49gssl7v5ghoa7wzrh</sha1>
</revision>
<revision>
<id>3167958</id>
<parentid>3167953</parentid>
<timestamp>2007-02-10T08:50:19Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<comment>/* Встроенные функции высших порядков */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="8092">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: [[Функция высшего порядка|функции высших порядков]], развитые средства [[Обработка списков|обработки списков]], [[Рекурсия#Рекурсия в программировании|рекурсия]], возможность организации [[Ленивые вычисления|ленивых вычислений]]. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Функция в Питон может быть определена с помощью оператора &lt;code&gt;def&lt;/code&gt; или лямбда-выражением. Следующие выражения эквивалентны:
def func(x, y):
return x**2 + y**2
func = lambda x, y: x**2 + y**2
Определив функцию с помощью [[лямбда-исчисление|лямбда-выражения]], можно тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям.
=== Встроенные функции высших порядков ===
В Питон есть функции, одним из аргументом которых являются другие функции: map(), filter(), reduce(), apply().
==== map() ====
Функция &lt;code&gt;map()&lt;/code&gt; позволяет обрабатывать один или несколько последовательностей с помощью заданной функции:
&gt;&gt;&gt; spisok1 = [7, 2, 3, 10, 12]
&gt;&gt;&gt; spisok2 = [-1, 1, -5, 4, 6]
&gt;&gt;&gt; map(lambda x, y: x*y, spisok1, spisok2)
[-7, 2, -15, 40, 72]
Аналогичного (только при одинаковой длине списков) результата можно добиться с помощью списковых выражений:
&gt;&gt;&gt; [x*y for x, y in zip(spisok1, spisok2)]
[-7, 2, -15, 40, 72]
==== filter() ====
Функция &lt;code&gt;filter()&lt;/code&gt; позволяет фильтровать значения последовательности. В результирующем списке только те значения, для которых значение функции для элемента истинно:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, spisok) # В результат попадают только те элементы x, для которых x &lt; 5 истинно
[4, 2, -1]
Тоже самое с помощью списковых выражений:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; [x for x in spisok if x &lt; 5]
[4, 2, -1]
==== reduce() ====
Для организации цепочечных вычислений в списке можно использовать функцию &lt;code&gt;reduce()&lt;/code&gt;. Например, произведение элементов списка может быть произведено так:
&gt;&gt;&gt; spisok = [1, 2, 3, 4, 5]
&gt;&gt;&gt; reduce(lambda res, x: res*x, spisok, 1)
120
Вычисления происходят в следующем порядке:
((((1*1)*2)*3)*4)*5
Цепочка вызовов связывается с помощью промежуточного результата (&lt;code&gt;res&lt;/code&gt;). Если список пустой, просто используется третий параметр (в случае произведения нуля множителей это 1):
&gt;&gt;&gt; reduce(lambda res, x: res*x, [], 1)
1
Разумеется, промежуточный результат необязательно число. Это может быть любой другой тип данных, в том числе и список. Следующий пример показывает ''реверс'' списка:
&gt;&gt;&gt; reduce(lambda res, x: [x]+res, [1, 2, 3, 4], [])
[4, 3, 2, 1]
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* [[Python#Генераторы|Генераторы и генераторные выражения]]
Некоторые примеры из книги рецептов:
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>c6216fk1u12zxaug7xdacqhz0w7c26l</sha1>
</revision>
<revision>
<id>3168024</id>
<parentid>3167958</parentid>
<timestamp>2007-02-10T09:01:38Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<comment>/* reduce() */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="8971">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: [[Функция высшего порядка|функции высших порядков]], развитые средства [[Обработка списков|обработки списков]], [[Рекурсия#Рекурсия в программировании|рекурсия]], возможность организации [[Ленивые вычисления|ленивых вычислений]]. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Функция в Питон может быть определена с помощью оператора &lt;code&gt;def&lt;/code&gt; или лямбда-выражением. Следующие выражения эквивалентны:
def func(x, y):
return x**2 + y**2
func = lambda x, y: x**2 + y**2
Определив функцию с помощью [[лямбда-исчисление|лямбда-выражения]], можно тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям.
=== Встроенные функции высших порядков ===
В Питон есть функции, одним из аргументом которых являются другие функции: map(), filter(), reduce(), apply().
==== map() ====
Функция &lt;code&gt;map()&lt;/code&gt; позволяет обрабатывать один или несколько последовательностей с помощью заданной функции:
&gt;&gt;&gt; spisok1 = [7, 2, 3, 10, 12]
&gt;&gt;&gt; spisok2 = [-1, 1, -5, 4, 6]
&gt;&gt;&gt; map(lambda x, y: x*y, spisok1, spisok2)
[-7, 2, -15, 40, 72]
Аналогичного (только при одинаковой длине списков) результата можно добиться с помощью списковых выражений:
&gt;&gt;&gt; [x*y for x, y in zip(spisok1, spisok2)]
[-7, 2, -15, 40, 72]
==== filter() ====
Функция &lt;code&gt;filter()&lt;/code&gt; позволяет фильтровать значения последовательности. В результирующем списке только те значения, для которых значение функции для элемента истинно:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, spisok) # В результат попадают только те элементы x, для которых x &lt; 5 истинно
[4, 2, -1]
Тоже самое с помощью списковых выражений:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; [x for x in spisok if x &lt; 5]
[4, 2, -1]
==== reduce() ====
Для организации цепочечных вычислений в списке можно использовать функцию &lt;code&gt;reduce()&lt;/code&gt;. Например, произведение элементов списка может быть произведено так:
&gt;&gt;&gt; spisok = [1, 2, 3, 4, 5]
&gt;&gt;&gt; reduce(lambda res, x: res*x, spisok, 1)
120
Вычисления происходят в следующем порядке:
((((1*1)*2)*3)*4)*5
Цепочка вызовов связывается с помощью промежуточного результата (&lt;code&gt;res&lt;/code&gt;). Если список пустой, просто используется третий параметр (в случае произведения нуля множителей это 1):
&gt;&gt;&gt; reduce(lambda res, x: res*x, [], 1)
1
Разумеется, промежуточный результат необязательно число. Это может быть любой другой тип данных, в том числе и список. Следующий пример показывает ''реверс'' списка:
&gt;&gt;&gt; reduce(lambda res, x: [x]+res, [1, 2, 3, 4], [])
[4, 3, 2, 1]
Для наиболее распространенных операций в Питон есть встроенные функции:
&gt;&gt;&gt; spisok = [1, 2, 3, 4, 5]
&gt;&gt;&gt; sum(spisok)
15
&gt;&gt;&gt; list(reversed(spisok))
[5, 4, 3, 2, 1]
==== apply() ====
Функция для применения другой функции к позиционным и именованным аргументам, заданным списком и словарем соответственно:
&gt;&gt;&gt; def f(x, y, z, a=None, b=None):
... print x, y, z, a, b
...
&gt;&gt;&gt; apply(f, [1, 2, 3], {'a': 4, 'b': 5})
1 2 3 4 5
В последних версиях Питон вместо функции &lt;code&gt;apply()&lt;/code&gt; можно применить специальный синтаксис (в продолжение примера выше):
&gt;&gt;&gt; f(*[1, 2, 3], **{'a': 4, 'b': 5})
1 2 3 4 5
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* [[Python#Генераторы|Генераторы и генераторные выражения]]
Некоторые примеры из книги рецептов:
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>23q39hhkx804z25mqf3e4y6mh4f80du</sha1>
</revision>
<revision>
<id>3168079</id>
<parentid>3168024</parentid>
<timestamp>2007-02-10T09:11:48Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<comment>/* Определение функции */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="10267">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: [[Функция высшего порядка|функции высших порядков]], развитые средства [[Обработка списков|обработки списков]], [[Рекурсия#Рекурсия в программировании|рекурсия]], возможность организации [[Ленивые вычисления|ленивых вычислений]]. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Функция в Питон может быть определена с помощью оператора &lt;code&gt;def&lt;/code&gt; или лямбда-выражением. Следующие выражения эквивалентны:
def func(x, y):
return x**2 + y**2
func = lambda x, y: x**2 + y**2
В определении функции фигурируют [[Формальный аргумент|формальные аргументы]]. Некоторые из них могут иметь значения по умолчанию. Все аргументы со значениями по умолчанию следуют после аргументов без значений [[по умолчанию]].
При вызове функции задаются [[Фактический аргумент|фактические аргументы]]. Например:
func(2, y=7)
В начале идут [[Позиционные аргументы|позиционные аргументы]]. Они сопоставляются с именами формальных аргументов по порядку. Затем следуют [[Именованные аргументы|именованные аргументы]]. Они сопоставляются по именам и могут быть заданы в вызове функции в любом порядке. Разумеется, все аргументы без значений по умолчанию должны быть заданы. Повторы в именах аргументов недопустимы.
Определив функцию с помощью [[лямбда-исчисление|лямбда-выражения]], можно тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям.
=== Встроенные функции высших порядков ===
В Питон есть функции, одним из аргументом которых являются другие функции: map(), filter(), reduce(), apply().
==== map() ====
Функция &lt;code&gt;map()&lt;/code&gt; позволяет обрабатывать один или несколько последовательностей с помощью заданной функции:
&gt;&gt;&gt; spisok1 = [7, 2, 3, 10, 12]
&gt;&gt;&gt; spisok2 = [-1, 1, -5, 4, 6]
&gt;&gt;&gt; map(lambda x, y: x*y, spisok1, spisok2)
[-7, 2, -15, 40, 72]
Аналогичного (только при одинаковой длине списков) результата можно добиться с помощью списковых выражений:
&gt;&gt;&gt; [x*y for x, y in zip(spisok1, spisok2)]
[-7, 2, -15, 40, 72]
==== filter() ====
Функция &lt;code&gt;filter()&lt;/code&gt; позволяет фильтровать значения последовательности. В результирующем списке только те значения, для которых значение функции для элемента истинно:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, spisok) # В результат попадают только те элементы x, для которых x &lt; 5 истинно
[4, 2, -1]
Тоже самое с помощью списковых выражений:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; [x for x in spisok if x &lt; 5]
[4, 2, -1]
==== reduce() ====
Для организации цепочечных вычислений в списке можно использовать функцию &lt;code&gt;reduce()&lt;/code&gt;. Например, произведение элементов списка может быть произведено так:
&gt;&gt;&gt; spisok = [1, 2, 3, 4, 5]
&gt;&gt;&gt; reduce(lambda res, x: res*x, spisok, 1)
120
Вычисления происходят в следующем порядке:
((((1*1)*2)*3)*4)*5
Цепочка вызовов связывается с помощью промежуточного результата (&lt;code&gt;res&lt;/code&gt;). Если список пустой, просто используется третий параметр (в случае произведения нуля множителей это 1):
&gt;&gt;&gt; reduce(lambda res, x: res*x, [], 1)
1
Разумеется, промежуточный результат необязательно число. Это может быть любой другой тип данных, в том числе и список. Следующий пример показывает ''реверс'' списка:
&gt;&gt;&gt; reduce(lambda res, x: [x]+res, [1, 2, 3, 4], [])
[4, 3, 2, 1]
Для наиболее распространенных операций в Питон есть встроенные функции:
&gt;&gt;&gt; spisok = [1, 2, 3, 4, 5]
&gt;&gt;&gt; sum(spisok)
15
&gt;&gt;&gt; list(reversed(spisok))
[5, 4, 3, 2, 1]
==== apply() ====
Функция для применения другой функции к позиционным и именованным аргументам, заданным списком и словарем соответственно:
&gt;&gt;&gt; def f(x, y, z, a=None, b=None):
... print x, y, z, a, b
...
&gt;&gt;&gt; apply(f, [1, 2, 3], {'a': 4, 'b': 5})
1 2 3 4 5
В последних версиях Питон вместо функции &lt;code&gt;apply()&lt;/code&gt; можно применить специальный синтаксис (в продолжение примера выше):
&gt;&gt;&gt; f(*[1, 2, 3], **{'a': 4, 'b': 5})
1 2 3 4 5
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* [[Python#Генераторы|Генераторы и генераторные выражения]]
Некоторые примеры из книги рецептов:
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>eex6y5iqwpbs91p84oztcg3unu4xgi1</sha1>
</revision>
<revision>
<id>3168089</id>
<parentid>3168079</parentid>
<timestamp>2007-02-10T09:13:52Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<comment>/* Определение функции */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="10785">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: [[Функция высшего порядка|функции высших порядков]], развитые средства [[Обработка списков|обработки списков]], [[Рекурсия#Рекурсия в программировании|рекурсия]], возможность организации [[Ленивые вычисления|ленивых вычислений]]. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Функция в Питон может быть определена с помощью оператора &lt;code&gt;def&lt;/code&gt; или лямбда-выражением. Следующие выражения эквивалентны:
def func(x, y):
return x**2 + y**2
func = lambda x, y: x**2 + y**2
В определении функции фигурируют [[Формальный аргумент|формальные аргументы]]. Некоторые из них могут иметь значения по умолчанию. Все аргументы со значениями по умолчанию следуют после аргументов без значений [[по умолчанию]].
При вызове функции задаются [[Фактический аргумент|фактические аргументы]]. Например:
func(2, y=7)
В начале идут [[Позиционные аргументы|позиционные аргументы]]. Они сопоставляются с именами формальных аргументов по порядку. Затем следуют [[Именованные аргументы|именованные аргументы]]. Они сопоставляются по именам и могут быть заданы в вызове функции в любом порядке. Разумеется, все аргументы без значений по умолчанию должны быть заданы. Повторы в именах аргументов недопустимы.
Функция в Питон всегда возвращает только одно значение (или &lt;code&gt;None&lt;/code&gt;, если значение не задано в операторе &lt;code&gt;return&lt;code/&gt; или этот оператор не встречен по достижении конца определения функции). Однако, это незначительное ограничение, так как возвращаемым значением может быть [[кортеж]].
Определив функцию с помощью [[лямбда-исчисление|лямбда-выражения]], можно тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям.
=== Встроенные функции высших порядков ===
В Питон есть функции, одним из аргументом которых являются другие функции: map(), filter(), reduce(), apply().
==== map() ====
Функция &lt;code&gt;map()&lt;/code&gt; позволяет обрабатывать один или несколько последовательностей с помощью заданной функции:
&gt;&gt;&gt; spisok1 = [7, 2, 3, 10, 12]
&gt;&gt;&gt; spisok2 = [-1, 1, -5, 4, 6]
&gt;&gt;&gt; map(lambda x, y: x*y, spisok1, spisok2)
[-7, 2, -15, 40, 72]
Аналогичного (только при одинаковой длине списков) результата можно добиться с помощью списковых выражений:
&gt;&gt;&gt; [x*y for x, y in zip(spisok1, spisok2)]
[-7, 2, -15, 40, 72]
==== filter() ====
Функция &lt;code&gt;filter()&lt;/code&gt; позволяет фильтровать значения последовательности. В результирующем списке только те значения, для которых значение функции для элемента истинно:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, spisok) # В результат попадают только те элементы x, для которых x &lt; 5 истинно
[4, 2, -1]
Тоже самое с помощью списковых выражений:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; [x for x in spisok if x &lt; 5]
[4, 2, -1]
==== reduce() ====
Для организации цепочечных вычислений в списке можно использовать функцию &lt;code&gt;reduce()&lt;/code&gt;. Например, произведение элементов списка может быть произведено так:
&gt;&gt;&gt; spisok = [1, 2, 3, 4, 5]
&gt;&gt;&gt; reduce(lambda res, x: res*x, spisok, 1)
120
Вычисления происходят в следующем порядке:
((((1*1)*2)*3)*4)*5
Цепочка вызовов связывается с помощью промежуточного результата (&lt;code&gt;res&lt;/code&gt;). Если список пустой, просто используется третий параметр (в случае произведения нуля множителей это 1):
&gt;&gt;&gt; reduce(lambda res, x: res*x, [], 1)
1
Разумеется, промежуточный результат необязательно число. Это может быть любой другой тип данных, в том числе и список. Следующий пример показывает ''реверс'' списка:
&gt;&gt;&gt; reduce(lambda res, x: [x]+res, [1, 2, 3, 4], [])
[4, 3, 2, 1]
Для наиболее распространенных операций в Питон есть встроенные функции:
&gt;&gt;&gt; spisok = [1, 2, 3, 4, 5]
&gt;&gt;&gt; sum(spisok)
15
&gt;&gt;&gt; list(reversed(spisok))
[5, 4, 3, 2, 1]
==== apply() ====
Функция для применения другой функции к позиционным и именованным аргументам, заданным списком и словарем соответственно:
&gt;&gt;&gt; def f(x, y, z, a=None, b=None):
... print x, y, z, a, b
...
&gt;&gt;&gt; apply(f, [1, 2, 3], {'a': 4, 'b': 5})
1 2 3 4 5
В последних версиях Питон вместо функции &lt;code&gt;apply()&lt;/code&gt; можно применить специальный синтаксис (в продолжение примера выше):
&gt;&gt;&gt; f(*[1, 2, 3], **{'a': 4, 'b': 5})
1 2 3 4 5
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* [[Python#Генераторы|Генераторы и генераторные выражения]]
Некоторые примеры из книги рецептов:
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>k5mj7o7okvolcnoaglhz4023fs9vimz</sha1>
</revision>
<revision>
<id>3168090</id>
<parentid>3168089</parentid>
<timestamp>2007-02-10T09:14:10Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<comment>/* Определение функции */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="10785">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: [[Функция высшего порядка|функции высших порядков]], развитые средства [[Обработка списков|обработки списков]], [[Рекурсия#Рекурсия в программировании|рекурсия]], возможность организации [[Ленивые вычисления|ленивых вычислений]]. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Функция в Питон может быть определена с помощью оператора &lt;code&gt;def&lt;/code&gt; или лямбда-выражением. Следующие выражения эквивалентны:
def func(x, y):
return x**2 + y**2
func = lambda x, y: x**2 + y**2
В определении функции фигурируют [[Формальный аргумент|формальные аргументы]]. Некоторые из них могут иметь значения по умолчанию. Все аргументы со значениями по умолчанию следуют после аргументов без значений [[по умолчанию]].
При вызове функции задаются [[Фактический аргумент|фактические аргументы]]. Например:
func(2, y=7)
В начале идут [[Позиционные аргументы|позиционные аргументы]]. Они сопоставляются с именами формальных аргументов по порядку. Затем следуют [[Именованные аргументы|именованные аргументы]]. Они сопоставляются по именам и могут быть заданы в вызове функции в любом порядке. Разумеется, все аргументы без значений по умолчанию должны быть заданы. Повторы в именах аргументов недопустимы.
Функция в Питон всегда возвращает только одно значение (или &lt;code&gt;None&lt;/code&gt;, если значение не задано в операторе &lt;code&gt;return&lt;/code&gt; или этот оператор не встречен по достижении конца определения функции). Однако, это незначительное ограничение, так как возвращаемым значением может быть [[кортеж]].
Определив функцию с помощью [[лямбда-исчисление|лямбда-выражения]], можно тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям.
=== Встроенные функции высших порядков ===
В Питон есть функции, одним из аргументом которых являются другие функции: map(), filter(), reduce(), apply().
==== map() ====
Функция &lt;code&gt;map()&lt;/code&gt; позволяет обрабатывать один или несколько последовательностей с помощью заданной функции:
&gt;&gt;&gt; spisok1 = [7, 2, 3, 10, 12]
&gt;&gt;&gt; spisok2 = [-1, 1, -5, 4, 6]
&gt;&gt;&gt; map(lambda x, y: x*y, spisok1, spisok2)
[-7, 2, -15, 40, 72]
Аналогичного (только при одинаковой длине списков) результата можно добиться с помощью списковых выражений:
&gt;&gt;&gt; [x*y for x, y in zip(spisok1, spisok2)]
[-7, 2, -15, 40, 72]
==== filter() ====
Функция &lt;code&gt;filter()&lt;/code&gt; позволяет фильтровать значения последовательности. В результирующем списке только те значения, для которых значение функции для элемента истинно:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, spisok) # В результат попадают только те элементы x, для которых x &lt; 5 истинно
[4, 2, -1]
Тоже самое с помощью списковых выражений:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; [x for x in spisok if x &lt; 5]
[4, 2, -1]
==== reduce() ====
Для организации цепочечных вычислений в списке можно использовать функцию &lt;code&gt;reduce()&lt;/code&gt;. Например, произведение элементов списка может быть произведено так:
&gt;&gt;&gt; spisok = [1, 2, 3, 4, 5]
&gt;&gt;&gt; reduce(lambda res, x: res*x, spisok, 1)
120
Вычисления происходят в следующем порядке:
((((1*1)*2)*3)*4)*5
Цепочка вызовов связывается с помощью промежуточного результата (&lt;code&gt;res&lt;/code&gt;). Если список пустой, просто используется третий параметр (в случае произведения нуля множителей это 1):
&gt;&gt;&gt; reduce(lambda res, x: res*x, [], 1)
1
Разумеется, промежуточный результат необязательно число. Это может быть любой другой тип данных, в том числе и список. Следующий пример показывает ''реверс'' списка:
&gt;&gt;&gt; reduce(lambda res, x: [x]+res, [1, 2, 3, 4], [])
[4, 3, 2, 1]
Для наиболее распространенных операций в Питон есть встроенные функции:
&gt;&gt;&gt; spisok = [1, 2, 3, 4, 5]
&gt;&gt;&gt; sum(spisok)
15
&gt;&gt;&gt; list(reversed(spisok))
[5, 4, 3, 2, 1]
==== apply() ====
Функция для применения другой функции к позиционным и именованным аргументам, заданным списком и словарем соответственно:
&gt;&gt;&gt; def f(x, y, z, a=None, b=None):
... print x, y, z, a, b
...
&gt;&gt;&gt; apply(f, [1, 2, 3], {'a': 4, 'b': 5})
1 2 3 4 5
В последних версиях Питон вместо функции &lt;code&gt;apply()&lt;/code&gt; можно применить специальный синтаксис (в продолжение примера выше):
&gt;&gt;&gt; f(*[1, 2, 3], **{'a': 4, 'b': 5})
1 2 3 4 5
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы и другие средства ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* [[Python#Генераторы|Генераторы и генераторные выражения]]
Некоторые примеры из книги рецептов:
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>0vopqr34ibeofdes06ptgqjfalir56q</sha1>
</revision>
<revision>
<id>3168179</id>
<parentid>3168090</parentid>
<timestamp>2007-02-10T09:35:13Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<comment>/* Итераторы и другие средства */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="12378">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: [[Функция высшего порядка|функции высших порядков]], развитые средства [[Обработка списков|обработки списков]], [[Рекурсия#Рекурсия в программировании|рекурсия]], возможность организации [[Ленивые вычисления|ленивых вычислений]]. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Функция в Питон может быть определена с помощью оператора &lt;code&gt;def&lt;/code&gt; или лямбда-выражением. Следующие выражения эквивалентны:
def func(x, y):
return x**2 + y**2
func = lambda x, y: x**2 + y**2
В определении функции фигурируют [[Формальный аргумент|формальные аргументы]]. Некоторые из них могут иметь значения по умолчанию. Все аргументы со значениями по умолчанию следуют после аргументов без значений [[по умолчанию]].
При вызове функции задаются [[Фактический аргумент|фактические аргументы]]. Например:
func(2, y=7)
В начале идут [[Позиционные аргументы|позиционные аргументы]]. Они сопоставляются с именами формальных аргументов по порядку. Затем следуют [[Именованные аргументы|именованные аргументы]]. Они сопоставляются по именам и могут быть заданы в вызове функции в любом порядке. Разумеется, все аргументы без значений по умолчанию должны быть заданы. Повторы в именах аргументов недопустимы.
Функция в Питон всегда возвращает только одно значение (или &lt;code&gt;None&lt;/code&gt;, если значение не задано в операторе &lt;code&gt;return&lt;/code&gt; или этот оператор не встречен по достижении конца определения функции). Однако, это незначительное ограничение, так как возвращаемым значением может быть [[кортеж]].
Определив функцию с помощью [[лямбда-исчисление|лямбда-выражения]], можно тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям.
=== Встроенные функции высших порядков ===
В Питон есть функции, одним из аргументом которых являются другие функции: map(), filter(), reduce(), apply().
==== map() ====
Функция &lt;code&gt;map()&lt;/code&gt; позволяет обрабатывать один или несколько последовательностей с помощью заданной функции:
&gt;&gt;&gt; spisok1 = [7, 2, 3, 10, 12]
&gt;&gt;&gt; spisok2 = [-1, 1, -5, 4, 6]
&gt;&gt;&gt; map(lambda x, y: x*y, spisok1, spisok2)
[-7, 2, -15, 40, 72]
Аналогичного (только при одинаковой длине списков) результата можно добиться с помощью списковых выражений:
&gt;&gt;&gt; [x*y for x, y in zip(spisok1, spisok2)]
[-7, 2, -15, 40, 72]
==== filter() ====
Функция &lt;code&gt;filter()&lt;/code&gt; позволяет фильтровать значения последовательности. В результирующем списке только те значения, для которых значение функции для элемента истинно:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, spisok) # В результат попадают только те элементы x, для которых x &lt; 5 истинно
[4, 2, -1]
Тоже самое с помощью списковых выражений:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; [x for x in spisok if x &lt; 5]
[4, 2, -1]
==== reduce() ====
Для организации цепочечных вычислений в списке можно использовать функцию &lt;code&gt;reduce()&lt;/code&gt;. Например, произведение элементов списка может быть произведено так:
&gt;&gt;&gt; spisok = [1, 2, 3, 4, 5]
&gt;&gt;&gt; reduce(lambda res, x: res*x, spisok, 1)
120
Вычисления происходят в следующем порядке:
((((1*1)*2)*3)*4)*5
Цепочка вызовов связывается с помощью промежуточного результата (&lt;code&gt;res&lt;/code&gt;). Если список пустой, просто используется третий параметр (в случае произведения нуля множителей это 1):
&gt;&gt;&gt; reduce(lambda res, x: res*x, [], 1)
1
Разумеется, промежуточный результат необязательно число. Это может быть любой другой тип данных, в том числе и список. Следующий пример показывает ''реверс'' списка:
&gt;&gt;&gt; reduce(lambda res, x: [x]+res, [1, 2, 3, 4], [])
[4, 3, 2, 1]
Для наиболее распространенных операций в Питон есть встроенные функции:
&gt;&gt;&gt; spisok = [1, 2, 3, 4, 5]
&gt;&gt;&gt; sum(spisok)
15
&gt;&gt;&gt; list(reversed(spisok))
[5, 4, 3, 2, 1]
==== apply() ====
Функция для применения другой функции к позиционным и именованным аргументам, заданным списком и словарем соответственно:
&gt;&gt;&gt; def f(x, y, z, a=None, b=None):
... print x, y, z, a, b
...
&gt;&gt;&gt; apply(f, [1, 2, 3], {'a': 4, 'b': 5})
1 2 3 4 5
В последних версиях Питон вместо функции &lt;code&gt;apply()&lt;/code&gt; можно применить специальный синтаксис (в продолжение примера выше):
&gt;&gt;&gt; f(*[1, 2, 3], **{'a': 4, 'b': 5})
1 2 3 4 5
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. Следующий пример иллюстрирует использование итераторов:
&gt;&gt;&gt; from itertools import chain
&gt;&gt;&gt; print list(chain(iter("ABC"), iter("DEF")))
['A', 'B', 'C', 'D', 'E', 'F']
В следующем примере иллюстрируется функция &lt;code&gt;groupby&lt;/code&gt; (группировать по), с помощью которой порождается список пар значение ключа и соответствующий ключу итератор (в этот итератор собраны все значения исходного списка с одинаковым значением ключа). В примере ключом является True или False в зависимости от положительности значения. (Для целей вывода каждый итератор превращается в список).
from math import cos
from itertools import groupby
lst = [cos(x*.4) for x in range(30)] # косинусоида
[list(y) for k, y in groupby(lst, lambda x: x &gt; 0)] # группы положительных и отрицательных чисел
В модуле &lt;code&gt;itertools&lt;/code&gt; есть и другие функции для работы с итераторами, позволяющие кратко (в функциональном стиле) и с вычислительной точки зрения - эффективно - выразить требуемые процессы обработки списков.
=== Модуль functools ===
В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* [[Python#Генераторы|Генераторы и генераторные выражения]]
Некоторые примеры из книги рецептов:
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>r1a79ci37umdy2pyu9avboh2vyrf49i</sha1>
</revision>
<revision>
<id>3168192</id>
<parentid>3168179</parentid>
<timestamp>2007-02-10T09:36:32Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<comment>/* Определение функции */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="12378">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: [[Функция высшего порядка|функции высших порядков]], развитые средства [[Обработка списков|обработки списков]], [[Рекурсия#Рекурсия в программировании|рекурсия]], возможность организации [[Ленивые вычисления|ленивых вычислений]]. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение функции ===
Функция в Питон может быть определена с помощью оператора &lt;code&gt;def&lt;/code&gt; или лямбда-выражением. Следующие операторы эквивалентны:
def func(x, y):
return x**2 + y**2
func = lambda x, y: x**2 + y**2
В определении функции фигурируют [[Формальный аргумент|формальные аргументы]]. Некоторые из них могут иметь значения по умолчанию. Все аргументы со значениями по умолчанию следуют после аргументов без значений [[по умолчанию]].
При вызове функции задаются [[Фактический аргумент|фактические аргументы]]. Например:
func(2, y=7)
В начале идут [[Позиционные аргументы|позиционные аргументы]]. Они сопоставляются с именами формальных аргументов по порядку. Затем следуют [[Именованные аргументы|именованные аргументы]]. Они сопоставляются по именам и могут быть заданы в вызове функции в любом порядке. Разумеется, все аргументы без значений по умолчанию должны быть заданы. Повторы в именах аргументов недопустимы.
Функция в Питон всегда возвращает только одно значение (или &lt;code&gt;None&lt;/code&gt;, если значение не задано в операторе &lt;code&gt;return&lt;/code&gt; или этот оператор не встречен по достижении конца определения функции). Однако, это незначительное ограничение, так как возвращаемым значением может быть [[кортеж]].
Определив функцию с помощью [[лямбда-исчисление|лямбда-выражения]], можно тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям.
=== Встроенные функции высших порядков ===
В Питон есть функции, одним из аргументом которых являются другие функции: map(), filter(), reduce(), apply().
==== map() ====
Функция &lt;code&gt;map()&lt;/code&gt; позволяет обрабатывать один или несколько последовательностей с помощью заданной функции:
&gt;&gt;&gt; spisok1 = [7, 2, 3, 10, 12]
&gt;&gt;&gt; spisok2 = [-1, 1, -5, 4, 6]
&gt;&gt;&gt; map(lambda x, y: x*y, spisok1, spisok2)
[-7, 2, -15, 40, 72]
Аналогичного (только при одинаковой длине списков) результата можно добиться с помощью списковых выражений:
&gt;&gt;&gt; [x*y for x, y in zip(spisok1, spisok2)]
[-7, 2, -15, 40, 72]
==== filter() ====
Функция &lt;code&gt;filter()&lt;/code&gt; позволяет фильтровать значения последовательности. В результирующем списке только те значения, для которых значение функции для элемента истинно:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, spisok) # В результат попадают только те элементы x, для которых x &lt; 5 истинно
[4, 2, -1]
Тоже самое с помощью списковых выражений:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; [x for x in spisok if x &lt; 5]
[4, 2, -1]
==== reduce() ====
Для организации цепочечных вычислений в списке можно использовать функцию &lt;code&gt;reduce()&lt;/code&gt;. Например, произведение элементов списка может быть произведено так:
&gt;&gt;&gt; spisok = [1, 2, 3, 4, 5]
&gt;&gt;&gt; reduce(lambda res, x: res*x, spisok, 1)
120
Вычисления происходят в следующем порядке:
((((1*1)*2)*3)*4)*5
Цепочка вызовов связывается с помощью промежуточного результата (&lt;code&gt;res&lt;/code&gt;). Если список пустой, просто используется третий параметр (в случае произведения нуля множителей это 1):
&gt;&gt;&gt; reduce(lambda res, x: res*x, [], 1)
1
Разумеется, промежуточный результат необязательно число. Это может быть любой другой тип данных, в том числе и список. Следующий пример показывает ''реверс'' списка:
&gt;&gt;&gt; reduce(lambda res, x: [x]+res, [1, 2, 3, 4], [])
[4, 3, 2, 1]
Для наиболее распространенных операций в Питон есть встроенные функции:
&gt;&gt;&gt; spisok = [1, 2, 3, 4, 5]
&gt;&gt;&gt; sum(spisok)
15
&gt;&gt;&gt; list(reversed(spisok))
[5, 4, 3, 2, 1]
==== apply() ====
Функция для применения другой функции к позиционным и именованным аргументам, заданным списком и словарем соответственно:
&gt;&gt;&gt; def f(x, y, z, a=None, b=None):
... print x, y, z, a, b
...
&gt;&gt;&gt; apply(f, [1, 2, 3], {'a': 4, 'b': 5})
1 2 3 4 5
В последних версиях Питон вместо функции &lt;code&gt;apply()&lt;/code&gt; можно применить специальный синтаксис (в продолжение примера выше):
&gt;&gt;&gt; f(*[1, 2, 3], **{'a': 4, 'b': 5})
1 2 3 4 5
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. Следующий пример иллюстрирует использование итераторов:
&gt;&gt;&gt; from itertools import chain
&gt;&gt;&gt; print list(chain(iter("ABC"), iter("DEF")))
['A', 'B', 'C', 'D', 'E', 'F']
В следующем примере иллюстрируется функция &lt;code&gt;groupby&lt;/code&gt; (группировать по), с помощью которой порождается список пар значение ключа и соответствующий ключу итератор (в этот итератор собраны все значения исходного списка с одинаковым значением ключа). В примере ключом является True или False в зависимости от положительности значения. (Для целей вывода каждый итератор превращается в список).
from math import cos
from itertools import groupby
lst = [cos(x*.4) for x in range(30)] # косинусоида
[list(y) for k, y in groupby(lst, lambda x: x &gt; 0)] # группы положительных и отрицательных чисел
В модуле &lt;code&gt;itertools&lt;/code&gt; есть и другие функции для работы с итераторами, позволяющие кратко (в функциональном стиле) и с вычислительной точки зрения - эффективно - выразить требуемые процессы обработки списков.
=== Модуль functools ===
В Python 2.5 появился модуль &lt;code&gt;functools&lt;/code&gt; и в частности возможность ''частичного применения функций'':
&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; def myfun(a, b): return a + b
...
&gt;&gt;&gt; myfun1 = partial(myfun, 1)
&gt;&gt;&gt; print myfun1(2)
3
=== Ленивые вычисления ===
[[Ленивые вычисления]] можно организовать в Питон несколькими способами, используя различные механизмы:
* простейшие логические операции or и and не вычисляют второй операнд, если результат определяется первым операндом
* [[лямбда-исчисление|лямбда-выражения]]
* определенные пользователем классы с ленивой логикой вычислений&lt;ref name="lazypy"&gt;[http://freshmeat.net/projects/lazypy/ Пакет lazypy]&lt;/ref&gt;
* [[Python#Генераторы|Генераторы и генераторные выражения]]
Некоторые примеры из книги рецептов:
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/280501 Ленивая сортировка]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивый обход графа]
* [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/498247 Ленивое вычисление свойств]
== Ссылки ==
* [http://linuxgazette.net/109/pramode.html Functional Programming with Python], Pramode C.E., Linux Gazette, 2004
* [http://www-128.ibm.com/developerworks/library/l-prog.html Charming Python: Functional programming in Python], David Mertz
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>lm7bjavq3zhhypyfxual8rrn8a851qc</sha1>
</revision>
<revision>
<id>3168199</id>
<parentid>3168192</parentid>
<timestamp>2007-02-10T09:37:07Z</timestamp>
<contributor>
<ip>62.248.239.110</ip>
</contributor>
<comment>/* Определение функции */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="12408">[[Функциональное программирование]] является одной из парадигм, поддерживаемых языком программирования [[Питон]]. Основными предпосылками для полноценного функционального программирования в Питон являются: [[Функция высшего порядка|функции высших порядков]], развитые средства [[Обработка списков|обработки списков]], [[Рекурсия#Рекурсия в программировании|рекурсия]], возможность организации [[Ленивые вычисления|ленивых вычислений]]. Элементы функционального программирования в Питон могут быть полезны любому программисту, так как позволяют гармонично сочетать выразительную мощность этого подхода с другими подходами.
== Возможности ==
=== Списочные выражения ===
Списочные выражения (''list comprehension'', иногда используется термин "списковые включения") — наиболее выразительное из функциональных средств Питона. Например, для вычисления списка квадратов натуральных чисел, меньших 10, можно использовать выражение:
l = [x**2 for x in range(10)]
=== Определение и использование функции ===
Функция в Питон может быть определена с помощью оператора &lt;code&gt;def&lt;/code&gt; или лямбда-выражением. Следующие операторы эквивалентны:
def func(x, y):
return x**2 + y**2
func = lambda x, y: x**2 + y**2
В определении функции фигурируют [[Формальный аргумент|формальные аргументы]]. Некоторые из них могут иметь значения по умолчанию. Все аргументы со значениями по умолчанию следуют после аргументов без значений [[по умолчанию]].
При вызове функции задаются [[Фактический аргумент|фактические аргументы]]. Например:
func(2, y=7)
В начале идут [[Позиционные аргументы|позиционные аргументы]]. Они сопоставляются с именами формальных аргументов по порядку. Затем следуют [[Именованные аргументы|именованные аргументы]]. Они сопоставляются по именам и могут быть заданы в вызове функции в любом порядке. Разумеется, все аргументы без значений по умолчанию должны быть заданы. Повторы в именах аргументов недопустимы.
Функция в Питон всегда возвращает только одно значение (или &lt;code&gt;None&lt;/code&gt;, если значение не задано в операторе &lt;code&gt;return&lt;/code&gt; или этот оператор не встречен по достижении конца определения функции). Однако, это незначительное ограничение, так как возвращаемым значением может быть [[кортеж]].
Определив функцию с помощью [[лямбда-исчисление|лямбда-выражения]], можно тут же ее использовать:
&gt;&gt;&gt; (lambda x: x+2)(5)
7
Лямбда-выражения удобны для определения не очень сложных функций, которые передаются затем другим функциям.
=== Встроенные функции высших порядков ===
В Питон есть функции, одним из аргументом которых являются другие функции: map(), filter(), reduce(), apply().
==== map() ====
Функция &lt;code&gt;map()&lt;/code&gt; позволяет обрабатывать один или несколько последовательностей с помощью заданной функции:
&gt;&gt;&gt; spisok1 = [7, 2, 3, 10, 12]
&gt;&gt;&gt; spisok2 = [-1, 1, -5, 4, 6]
&gt;&gt;&gt; map(lambda x, y: x*y, spisok1, spisok2)
[-7, 2, -15, 40, 72]
Аналогичного (только при одинаковой длине списков) результата можно добиться с помощью списковых выражений:
&gt;&gt;&gt; [x*y for x, y in zip(spisok1, spisok2)]
[-7, 2, -15, 40, 72]
==== filter() ====
Функция &lt;code&gt;filter()&lt;/code&gt; позволяет фильтровать значения последовательности. В результирующем списке только те значения, для которых значение функции для элемента истинно:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; filter(lambda x: x &lt; 5, spisok) # В результат попадают только те элементы x, для которых x &lt; 5 истинно
[4, 2, -1]
Тоже самое с помощью списковых выражений:
&gt;&gt;&gt; spisok = [10, 4, 2, -1, 6]
&gt;&gt;&gt; [x for x in spisok if x &lt; 5]
[4, 2, -1]
==== reduce() ====
Для организации цепочечных вычислений в списке можно использовать функцию &lt;code&gt;reduce()&lt;/code&gt;. Например, произведение элементов списка может быть произведено так:
&gt;&gt;&gt; spisok = [1, 2, 3, 4, 5]
&gt;&gt;&gt; reduce(lambda res, x: res*x, spisok, 1)
120
Вычисления происходят в следующем порядке:
((((1*1)*2)*3)*4)*5
Цепочка вызовов связывается с помощью промежуточного результата (&lt;code&gt;res&lt;/code&gt;). Если список пустой, просто используется третий параметр (в случае произведения нуля множителей это 1):
&gt;&gt;&gt; reduce(lambda res, x: res*x, [], 1)
1
Разумеется, промежуточный результат необязательно число. Это может быть любой другой тип данных, в том числе и список. Следующий пример показывает ''реверс'' списка:
&gt;&gt;&gt; reduce(lambda res, x: [x]+res, [1, 2, 3, 4], [])
[4, 3, 2, 1]
Для наиболее распространенных операций в Питон есть встроенные функции:
&gt;&gt;&gt; spisok = [1, 2, 3, 4, 5]
&gt;&gt;&gt; sum(spisok)
15
&gt;&gt;&gt; list(reversed(spisok))
[5, 4, 3, 2, 1]
==== apply() ====
Функция для применения другой функции к позиционным и именованным аргументам, заданным списком и словарем соответственно:
&gt;&gt;&gt; def f(x, y, z, a=None, b=None):
... print x, y, z, a, b
...
&gt;&gt;&gt; apply(f, [1, 2, 3], {'a': 4, 'b': 5})
1 2 3 4 5
В последних версиях Питон вместо функции &lt;code&gt;apply()&lt;/code&gt; можно применить специальный синтаксис (в продолжение примера выше):
&gt;&gt;&gt; f(*[1, 2, 3], **{'a': 4, 'b': 5})
1 2 3 4 5
=== Замыкания ===
Функции, определяемые внутри других функций, представляют собой полноценные '''замыкания''' ({{lang-en|closures}}):
def multiplier(n):
"multiplier(n) возвращает функцию, умножающую на n"
def mul(k):
return n*k
return mul
# того же эффекта можно добиться выражением
# multiplier = lambda n: lambda k: n*k
mul2 = multiplier(2) # mul2 - функция, умножающая на 2, например, mul2(5) == 10
=== Итераторы ===
Другие средства функционального программирования доступны из стандартной библиотеки (например, модуль &lt;code&gt;itertools&lt;/code&gt;) и других библиотек. Следующий пример иллюстрирует использование итераторов:
&gt;&gt;&gt; from itertools import chain
&gt;&gt;&gt; print list(chain(iter("ABC"), iter("DEF")))
['A', 'B', 'C', 'D', 'E', 'F']
В следующем примере иллюстрируется