Пайтон программирование – Программирование на Python — курс для желающих узнать о нём больше или изучить ещё один язык программирования / Образовательные проекты JetBrains corporate blog / Habr

Содержание

книги для начинающих / Habr

Друзья, забирайте в закладки подборку из 17 книг по Python.

Подборка поможет вам освоить язык программирования с нуля или с минимальными знаниями.
Готовы приступить к изучению Python?

Тогда начнем!

Начинаем подготовку к изучению Python


Если вы не переходите на Python с другого языка программирования, а начинаете с нуля, сначала разберитесь в базовых понятиях разработки. Чтобы читать техническую литература на английском, подтяните уровень языка. В этом помогут книги:

«Computer Programming for Beginners: Fundamentals of Programming Terms and Concepts», Натан Кларк

Новички могут легко утонуть в профессиональных понятиях. Эта книга поможет разобраться в терминологии: что такое функции, функциональное и объектно-ориентированное программирование, как структурировать и развернуть программу, как хранить, управлять и обмениваться данными.

«English for Information Technology», Пирсон Лонгман

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

«Basic English for Computing», Оксфорд

Учебный курс, который поможет улучшить навыки грамматики, пополнить словарный запас техническими терминами. Фишка книги — она содержит тексты и диаграммы для лучшего понимания материала, словарь современных вычислительных терминов, сокращений и символов.

Знакомимся с Python


Начните изучать язык программирования с теоретических основ — разберитесь в терминах, принципах работы языка. Для этого изучите книги:

«Hello World. Занимательное программирование», Картер Сэнд, Уоррен Сэнд

Простая книга для введения в Python — автор объясняет основные термины, особенности языка доступным языком. Издание в основном теоретическое, из практики — руководства по созданию нескольких элементарных программ.

«Программируем на Python», Майкл Доусон

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

Переходим к практике


Когда разберетесь в теоретических основах, переходите на книги с практикой — реальными примерами кода, задачами, руководствами по разработке первых простых проектов:

«Изучаем Python», Марц Лутц

Автор описывает основные типы объектов в Python, порядок их создания и дальнейшей работы с ними, рассказывает об основном процедурном элементе языка — функциях. После каждой главы приводит контрольные вопросы для закрепления материала, а после каждой части — практические упражнения.

«Программирование на Python», Марк Лутц

Руководство по использованию Python в различных сферах — системном администрировании, создании веб-приложений и графических интерфейсов. Автор рассказывает, как работать с базами данных, программировать сетевые взаимодействия, создавать интерфейсы для сценариев и других задач.

«Python — к вершинам мастерства», Лучано Рамальо

Книга разработчика Лучано Рамальо для тех, кто уже научился писать на языке Python, но еще не использует все его возможности. Автор рассказывает о базовых средствах и библиотеках языка и приводит наглядные примеры, как сделать код короче, понятнее и быстрее.

«Python Programming: A Step By Step Guide For Beginners», Брайан Дженкинс

Пошаговое руководство для новичков, которые хотят освоить язык программирования с нуля. Автор объясняет базовый синтаксис, учит работать с типами данными и переменными, классами и объектами, обрабатывать файлы и исключения.

«Python Programming: The Basic, Blackhat, Intermediary and Advanced Guide to Python Programming», Ричард Озер

Эта книга — полноценное руководство по Python, состоящее из четырех частей. Новичкам стоит изучить первую часть книги. Автор просто и понятно рассказывает о механизмах работы Python, как разобраться в основах языка и написать свою первую программу.

«Python Programming Illustrated For Beginners & Intermediates: «Learn By Doing» Approach-Step By Step Ultimate Guide To Mastering Python: The Future Is Here!», Вильям Салливан

Пошаговое руководство, которое поможет освоить язык Python и применять его на практике. Автор рассказывает, как запустить первую программу, описывает переменные, типы данных, идентификаторы и делится другой полезной информацией.

«Python на практике», Марк Саммерфилд

Книга для новичков, которые уже освоили язык Python и хотят программировать лучше. Автор рассказывает, как использовать паттерны программирования, чтобы улучшить код, проводить распараллеливание и компиляцию программ, объясняет принципы высокоуровневого сетевого программирования и графики.

Продолжаем изучение: книги о Python по направлениям


Python можно использовать для решения многих задач — работы с сайтами, веб-приложениями, машинного обучения. Определитесь, в каком направлении хотите развиваться, и начните с профильной литературы:

«ГИС-приложения — Разработка геоприложений на языке Python», Эрик Вестра

Автор подробно рассказывает, как писать геоприложения. Вы научитесь получать доступ к геоданным и визуализировать их, читать и записывать данные в векторном и растровом формате, хранить и получать доступ, выполнять геопропространственные расчеты на языке Python.

«Скрапинг сайтов — Скрапинг веб-сайтов с помощью Python», Райан Митчелл

Руководство, как примененять скрипты Python и веб-API, чтобы собирать и обрабатывать данные с тысяч сайтов. Будет интересна программистам и веб-администраторам, которые хотят изучить работу веб-скраперов, освоить анализ сырых данных и тестирование интерфейса.

«Введение в машинное обучение с помощью Python. Руководство для специалистов по работе с данными», Андреас Мюллер, Сара Гвидо

Книга для новичков. Авторы доступно для понимания рассказывают, как строить системы машинного обучения, подробно объясняют этапы работы с применением Python и библиотек scikit-learn, NumPy и matplotlib.

«Django. Подробное руководство», Адриан Головатый, Джейкоб Каплан-Мосс

Книга о Django — фреймворке для разработки веб-приложений на Python. Авторы рассказывают о компонентах фреймворка и методах работы с ним, приводят примеры применения в разных проектах.

«Разработка веб-приложений с использованием Flask на языке Python», Мигель Гринберг

Автор учит работать с популярным фреймворком Flask, приводит пошаговое руководство, как создать приложение социального блогинга. Узнаете возможности фреймворка, научитесь расширять приложения дополнительными технологиями.

Основы Python в кратком изложении / Habr

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

Python для начинающих. Глава первая. «О чем это мы»

На всякий случай, немного скучного «evangelism». Кому он надоел, можно пропустить несколько абзацев.
Python (читается как «Пайтон» а не «питон») — скриптовый язык, разработанный Гвидо ван Россумом в качестве простого языка, легкого в изучении новичку.
В наше время Пайтон – широко распространенный язык, который используется во многих областях:
— Разработка прикладного ПО (например linux-утилиты yum, pirut, system-config-*, IM-клиент Gajim и многие другие)
— Разработка web-приложений (мощнейший Application-сервер Zope и разработанная на его основе CMS Plone, на основе которой работает например сайт ЦРУ, и масса фреймворков для быстрой разработки приложений Plones, Django, TurboGears и многие другие)
— Использование в качестве встраиваемого скриптового языка во многих играх, и не только (в офисном пакете OpenOffice.org, 3d редакторе Blender, СУБД Postgre)
— Использование в научных рассчетах (с пакетами SciPy и numPy для расчетов и PyPlot для рисования графиков Пайтон становится практически сравним с пакетами типа MatLab)

И это конечно далеко не полный список проектов, использующих этот замечательный язык.

1. Сам интерпретатор, его можно взять тут (http://python.org/download/).
2. Среда разработки. Она для начала необязательна, да и идущий в дистрибутиве IDLE подойдет новичку, но для серъезных проектов нужно что-то посерьезней.
Для Windows я использую замечательный легковесный PyScripter (http://tinyurl.com/5jc63t), для Linux – Komodo IDE.

Хотя для первого урока достаточно будет просто интерактивной оболочки самого Пайтона.

Просто запустите python.exe. Приглашение ввода не заставит себя долго ждать, оно выглядит так:

>>>

Также можно записывать программы в файлы с расширением py, в вашем любимом текстовом редакторе, который не добавляет к тексту своих символов разметки (нет Word не подойдет). Также желательно чтобы этот редактор умел делать «умные табуляторы» и не заменял пробелы знаком табуляции.
Для запуска файлов на исполнение по ним можно щелкать 2 раза. Если консольное окно закрывается слишком быстро, вставьте в конце программы следующую строку:

raw_input()

Тогда интерпретатор будет в конце программы ждать нажатия enter.

Или ассоциируйте py-файлы в Far с Пайтоном и открывайте нажимая enter.

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

Немного теории.

Для начала, Пайтон – язык со строгой динамической типизацией. Что это означает?

Есть языки со строгой типизацией (pascal, java, c и т.п.), у которых тип переменной определяется заранее и не может быть изменен, и есть языки с динамической типизацией (python, ruby, vb), в которых тип переменной трактуется в зависимости от присвоенного значения.
Языки с динамической типизацией можно разделить еще на 2 вида. Строгие, которые не допускают неявного преобразования типа (Пайтон) и нестрогие, которые выполняют неявные преобразования типа (например VB, в котором можно легко сложить строку '123' и число 456).
Разобравшись с классификацией Пайтона, попробуем немного «поиграть» с интерпретатором.

>>> a = b = 1
>>> a, b
(1, 1)
>>> b = 2
>>> a, b
(1, 2)
>>> a, b = b, a
>>> a, b
(2, 1)

Таким, образом мы видим что присваивание осуществляется с помощью знака =. Присвоить значение можно сразу нескольким переменным. При указании интерпретатору имени переменной в интерактивном режиме, он выводит ее значение.

Следующее, что необходимо знать – как строятся базовые алгоритмические единицы – ветвления и циклы. Для начала, необходима небольшая справка. В Пайтоне нет специального ограничителя блоков кода, их роль выполняют отступы. То есть то что написано с одинаковым отступом – является одним командным блоком. Поначалу это может показаться странным, но после легкого привыкание, понимаешь что эта «вынужденная» мера позволяет получать очень читабельный код.
Итак условия.

Условие задается с помощью оператора if, который заканчивается «:». Альтернативные условия которые будут выполняться если первая проверка «не прошла» задаются оператором elif. Наконец else задает ветку, которая будет выполнена если ни одно из условий не подошло.
Обратите внимание, что после ввода if интерпретатор с помощью приглашения «...» показывает что он ожидает продолжения ввода. Чтобы сообщить ему что мы закончили, необходимо ввести пустую строку.

(Пример с ветвлениями почему-то рвет разметку на хабре, не смотря на танцы с тегами pre и code. Простите за неудобство, я его кинул сюда pastebin.com/f66af97ba, если кто-то подскажет что не так — буду очень признателен)

Циклы.

Простейшим случаем цикла является цикл while. В качестве параметра он принимает условие и выполняется до тех пор, пока оно истино.
Вот маленький пример.

>>> x = 0
>>> while x<=10:
...     print x
...     x += 1
...
0
1
2
...........
10

Обратите внимание что поскольку и print x и x+=1 написаны с одинаковым отступом, они считаются телом цикла (помните что я говорил про блоки? 😉 ).

Второй вид циклов в Пайтон – цикл for. Он аналогичен циклу foreach других языков. Его синтаксис условно таков.

for переменная in список:
команды

Переменной будут присваиваться по очереди все значения из списка (на самом деле там может быть не только список, но и любой другой итератор, но не будем пока этим забивать голову).

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

>>> x = "Hello, Python!"

>>> for char in x:
...     print char
...
H
e
l
...........
!

Таким образом мы можем разложить строку по символам.
Что же делать если нам нужен цикл, повторяющийся определенное число раз? Очень просто, на помощь придет функция range.

На входе она принимает от одного до трех параметров, на выходе возвращает список чисел, по которому мы можем «пройтись» оператором for.

Вот несколько примеров использования функции range, которые объясняют роль ее параметров.

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(2, 12)
[2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
>>> range(2, 12, 3)
[2, 5, 8, 11]
>>> range(12, 2, -2)
[12, 10, 8, 6, 4]

И маленький пример с циклом.

>>> for x in range(10):
...     print x
...
0
1
2
.....
9

Ввод-вывод

Последнее, что следует знать перед тем как начать использовать Пайтон полноценно – это как осуществляется в нем ввод-вывод.

Для вывода используется команда print, которая выводит на печать все свои аргументы в удобочитаемом виде.

Для ввода с консоли используется функция raw_input(приглашение), которая выводит на экран приглашение и ожидает ввода пользователя, возвращая то что ввел пользователь в виде своего значения.

x = int(raw_input ("Введи число:"))
print "Квадрат этого числа составляет ", x * x

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

Вот и все для первого урока.

Домашнее задание.

1. Составить программу расчета гипотенузы прямоугольного треугольника. Длина катетов запрашивается у пользователя.
2. Составить программу нахождения корней квадратного уравнения в общем виде. Коэффициенты запрашиваются у пользователя.
3. Составить программу вывода таблицы умножения на число M. Таблица составляется от M * a, до M * b, где M, a, b запрашиваются у пользователя. Вывод должен осуществляется в столбик, по одному примеру на строку в следующем виде (например):
5 х 4 = 20
5 х 5 = 25
И так далее.

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

Пошаговая инструкция для всех, кто хочет изучить программирование на Python (или программирование вообще), но не знает, куда сделать первый шаг.

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

1. Первым делом изучите основы. Узнайте, что такое переменные, управляющие структуры, структуры данных. Эти знания необходимы без привязки к конкретному языку.

2. Займитесь изучением литературы. Начните с классики – Dive into Python. Эта книга вообще может стать настольной. Еще можно почитать Майкла Доусона "Программируем на Python" и Алексея Васильева "Python на примерах. Практический курс по программированию". Доусон – опытный программист и преподаватель, а в книге учит программировать, создавая простые игры. В книге Васильева, напротив, больше внимания уделяется основам и теории.

3. Практикуйтесь. Можно (и нужно) делать это параллельно с изучением теории. Пройдите курс Learn Python на Codecademy: вся необходимая для выполнения заданий теория подается прямо во время заданий. Как вариант, можно посетить Питонтьютор – бесплатный интерактивный курс по Python на русском.
Также есть хорошие курсы на Stepik:
Программирование на Python, Python: основы и применение

4. Пройдите курс «Введение в компьютерные технологии и программирование на языке Python» от MIT.

5. Узнайте, какие библиотеки и инструменты Python и для каких целей используют другие питонисты. Найдите что-то интересное для себя.

6. Если вас интересуют веб-технологии, обратите внимание на фреймворки Flask и Django. Узнайте, для каких целей какой из них лучше подходит, начните изучать тот, что подходит вам.

7. Узнайте, как получать и анализировать массивы данных с отдельных сайтов, со всего Интернета и вообще откуда угодно – только старайтесь держаться в рамках закона.

8. Ищите информацию о методах машинного обучения.

9. Оптимизируйте работу с инструментами, автоматизируйте рутину и все, что еще не автоматизировано.

Несколько полезных ссылок на ресурсы, которые помогут чуть меньше гуглить и определиться, в каком направлении работать.

Полезные ресурсы

Python Tutor

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

Bucky Roberts на YouTube

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

Derek Banas про Python на YouTube

Дерек – программист-самоучка, и у него свой взгляд на подход к изучению языков программирования. Он делает небольшие видеообзоры на различные языки длиной в 40-60 минут, в которых рассказывает все, что нужно, чтобы в общих чертах понять назначение языка.

Corey Schafer на YouTube

У Кори хорошие видео на тему форматирования строк, генераторов, программистских терминов (комбинации и перестановки, DRY, замыкания) и многого другого, что поможет понять основные концепции.

Django Getting Started

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

Введение во Flask

Видеокурс на YouTube для желающих ознакомиться с Flask, понять некоторые его тонкости и узнать, зачем он вообще нужен.

Полезные ссылки

Новичку

Python 3 для начинающих
"Укус Питона" (англ. "A Byte of Python")
Видеолекции от JetBrains
Спецкурс ВМК МГУ по Python
Интерактивный онлайн-учебник
Бизли Д. "Python. Подробный справочник" (2010, PDF)
Прохоренок Н.А. "Python 3 и PyQt. Разработка приложений" (2012, PDF)
Программирование на Python 3.Подробное руководство
Программирование на Python для начинающих (2015, PDF)
Самоучитель Python 3 (2015, PDF)

Знающему основы для углубленного изучения

М. Лутц "Программирование на Python, 4-е издание" (2011, PDF): первый том, второй том
Программирование компьютерного зрения на Python (2016)
Л. Рамальо «Python. К вершинам мастерства» (2015)
М. Лутц "Изучаем Python" (4-е издание) (2011, DjVu)
Justin Seiz "Gray Hat Python"(rus) (2012, PDF)
Гифт Н., Джонс Дж.М. "Python в системном администрировании UNIX и Linux" (2009, PDF)
М. Саммерфилд "Программирование на Python 3. Подробное руководство" (2009, PDF)

Профессионалу

Много всего на Хабрахабре
Подборка англоязычных книг по различным областям применения Python
Python Machine Learning (2015, PDF)

Видеоматериалы

Некоторые записи видео-конференции Python Meetup

Путь Python Junior-а в 2017

10 скрытых особенностей Python

Как начать программировать на Python

Разберём, как устроены базовые функции в Python.

Чтобы записать в переменную V сумму 1 и 1, мы напишем так:

Если мы захотим напечатать переменную V, мы используем функцию:

Напоминаем, что в Python мы не пишем тип переменных.

При спуске этот код выведет нам 2.

Если вы забыли, что делает функция, или нашли новую, вам поможет команда help (): она выпишет основную информацию о функции. Если мы используем ее на функцию print (), это будет выглядеть так:

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

Есть и операции поинтереснее, менее очевидные:

Иногда в Python можно встретить артефакты вроде такого:

1 – 1.3 = -0.30000000004.

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

Вывод текста. Уже сложилась традиция, что первые слова, которые человек выписывает кодом, это «Hello, World!». Сделаем это и мы.

Мы уже выводили выше переменную, теперь выведем текст. Сделать это в Python очень просто:

print(“Hello, World!”)

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

name = “Valentin”
print(“Hello, {}!”.format(name))
>>> Hello, Valentin!

В некоторых версиях Python можно сделать то же самое и другим способом:

print(f“Hello, {name}!”)

Результат будет один и тот же. Если у вас работают обе версии, то делайте так, как вам больше нравится.

  1. Операции сравнения будут возвращать ответ в виде правда/неправда: True/False.
  2. Для проверки на равенство используются два знака «равно».
  3. Для проверки на неравенство используется восклицательный знак (знак отрицания) со знаком «равно».

Например:

A = 5
B = 10
A > B
>>>False
A < B
>>>True
A == B
>>>False
A != B
>>>True
A == 5
>>>True

Python. Введение в программирование. Курс для начинающих

Логотип курса по Python

Курс "Python. Введение в программирование" рассчитан на старшеклассников и всех желающих познакомиться с программированием. В курсе рассматриваются основные типы данных, принципы и понятия структурного программирования. Используется версия языка Python ветки 3.x.

Выбор Python обусловлен такими его преимуществами как ясность кода и быстрота реализации на нем программ.

Курс рассчитан примерно на 25 часов.

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

Текущая версия курса: октябрь 2019 г.

Вы можете приобрести android-приложение или pdf-версию курса с ответами и пояснениями к практическим работам, а также дополнительными уроками - "Генераторы списков", "Матрицы", "Множества", "Особенности работы операторов and и or в Python", "Lambda-выражения". 

Программа курса

1. Краткая история языков программирования
История программирования в кратком и понятном изложении. Что такое машинный язык, почему появились ассемблеры, языки высокого уровня и объектно-ориентированные. Зачем нужен транслятор, и почему он может быть либо компилятором, либо интерпретатором.
2. Знакомство с Python
Особенности языка Python, работа в интерактивном режиме и подготовка файлов с исходным кодом.
3. Типы данных. Переменные
Базовые типы данных в Python: целое, вещественное числа, строки. Изменение типа данных с помощью встроенных функций. Понятие об операциях и переменных. Присваивание значения переменной.
4. Ввод и вывод данных
Для вывода на экран в Python 3.x используется функция print(). Вывод может быть предварительно отформатирован. Для ввода данных с клавиатуры используется функция input(), которая возвращает в программу строку.
5. Логические выражения и операторы
Логические выражения. Логические операторы языка Python: == (равно), != (не равно), (больше), = (больше или равно), and (логическое И), or (логическое ИЛИ), not (отрицание).
6. Ветвление. Условный оператор
Ветвление в Python реализуется с помощью условный оператора if-else. Ветка if выполняется если условие верно, необязательная ветка else - в остальных случаях.
7. Ошибки и исключения. Обработка исключений
Общее представление об ошибках и исключениях в языке программирования Python. SyntaxError, NameError, TypeError, ValueError, ZeroDivisionError. Обработка исключений с помощью инструкции try-except.
8. Множественное ветвление: if-elif-else
Оператор множественного ветвления языка Python позволяет организовать более двух веток выполнения программы без необходимости вложения условных операторов друг в друга. Конструкция включает одну ветку if, произвольное количество elif и необязательную ветку else.
9. Циклы в программировании. Цикл while
С помощью циклов в программировании организуется многократное следующее друг за другом выполнение одних и тех же участков кода. Бывают циклы с условием и со счетчиком. К первым относится цикл while, или цикл "пока". 
10. Функции в программировании
Функции - важный элемент структурного программирования. Они позволяют обособить участок кода, выполняющий определенную задачу. В дальнейшем к нему можно обращаться из разных мест программы по имени, которым он назван. В языке Python функции определяются с помощью оператора def.
11. Локальные и глобальные переменные
В программировании важное значение имеет представление о локальных и глобальных переменных. Локальные переменные существуют внутри функций и не доступны за ее пределами. Глобальные переменные видны во всей программе. 
12. Возврат значений из функции. Оператор return
С помощью оператора return можно вернуть значение из тела функции в основную программу. В языке программирования Python можно вернуть несколько значений, перечислив их через запятую после оператора return. Также в функции может быть несколько return, но всегда выполняется только один из них.
13. Параметры и аргументы функции
Если функция имеет параметры, то при вызове в нее можно передавать данные в виде аргументов-значений или аргументов-ссылок. Параметры перечисляются в заголовке функции в скобках после имени, представляют собой локальные переменные. В Python тип параметров не указывается, хотя в других языках это может быть обязательным требованием.
14. Встроенные функции
Язык программирования Python включает множество встроенных функций. В предыдущих уроках мы использовали такие функции как print() и input(), а также функции преобразования типов данных. В этом уроке рассматриваются встроенные функции для работы с символами и числами.
15. Модули
Использование модулей в программировании позволяет изолировать код, выполняющий частные задачи, в отдельные файлы. После чего обращаться к нему из разных программ. Создание модулей - следующий шаг после функций, когда участок кода обособляется внутри одного файла-программы. Для языка Python есть множество встроенных и сторонних модулей. 
16. Генератор псевдослучайных чисел – random
Для генерации псевдослучайных чисел в языке программирования Python используются функции модуля random. Функция random() генерирует вещественное число от 0 до 1. Функции randint() и randrange() производят целые псевдослучайные числа в указанных диапазонах.
17. Списки
Списки в Python - это аналог массивов в других языках программирования. Однако список может содержать элементы разных типов. В терминологии Python список - это изменяемая упорядоченная структура данных. Можно заменять его элементы, добавлять и удалять их, брать срезы. В язык встроены методы для работы со списками.
18. Цикл for
Цикл for в языке программирования Python предназначен для перебора элементов структур данных (списков, словарей, кортежей, множеств) и многих других объектов. Это не цикл со счетчиком, каковым является for во многих других языках. Нередко цикл for используется совместно с функцией range(), генерирующей объекты-диапазоны.
19. Строки
В Python строки - это неизменяемые последовательности символов или подстрок. Из них, так же как из списков, можно извлекать отдельные символы с помощью индексов или подстроки с помощью взятия срезов. В языке Python есть множество встроенных строковых методов, позволяющих упростить обработку строк.
20. Кортежи
Кортежи в Python - это неизменяемые структуры данных, состоящие из элементов одного или разных типов. Кортежи подобны спискам и обычно используются для защиты последних от изменений. Преобразование одного в другой выполняется с помощью встроенных функций tuple() и list().
21. Словари
Словарь в Python - это изменяемая неупорядоченная структура данных, элементами которой являются пары "ключ:значение". В словари можно добавлять и удалять элементы, изменять значения ключей. В Python словари имеют ряд методов, упрощающих работу с ними. 
22. Файлы
В языке программирования Python открытие файлов выполняется с помощью функции open(), которой передается два аргумента - имя файла и режим. Файл может быть открыт в режиме чтения, записи, добавления. Также может быть указан тип файла - текстовый или бинарный. Для файлов есть ряд встроенных методов чтения, записи и др.
Итоги курса "Python. Введение в программирование"
В этом курсе были изучены основы структурного программирования, в качестве инструмента использовался язык Python. Были рассмотрены встроенные типы данных, ветвления и циклы, обработчик исключений, функции, работа с модулями. Одной из целей курса является подготовка к изучению объектно-ориентированного программирования.

«Простое» программирование на python / Habr


functools (это такая свалка для всяких ненужных мне вещей :-).
— Гвидо ван Россум

Может показаться, что статья о ФП, но я не собираюсь обсуждать парадигму. Речь пойдет о переиспользовании и упрощении кода — я попытаюсь доказать, что вы пишете слишком много кода, поэтому он сложный и тяжело тестируется, но самое главное: его долго читать и менять.

В статье заимствуются примеры и/или концепции из библиотеки funcy. Во-первых, она клевая, во-вторых, вы сразу же сможете начать ее использовать. И да, нам понадобится ФП.


Кратко о ФП


  • чистые функции
  • функции высшего порядка
  • чувство собственного превосходства над теми, кто пишет не функционально (необязательно)

ФП также присущи следующие приемы:

  • частичное применение
  • композирование (в python еще есть декораторы)
  • ленивые вычисления

Если вам все это уже знакомо, переходите сразу к примерам.


Чистые функции

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

Напишем функцию-фильтр, которая возвращает список элементов с тру-значениями.

pred = bool
result = []

def filter_bool(seq):
    for x in seq:
        if pred(x):
            result.append(x)
    return result

Сделаем ее чистой:

pred = bool

def filter_bool(seq):
    result = []
    for x in seq:
        if pred(x):
            result.append(x)
    return result

Теперь можно вызвать ее лярд раз подряд и результат будет тот же.


Функции высшего порядка

Это такие функции, которые принимают в качестве аргументов другие функции или возвращают другую функцию в качестве результата.

def my_filter(pred, seq):
    result = []
    for x in seq:
        if pred(x):
            result.append(x)
    return result

Мне пришлось переименовать функцию, потому что она теперь куда полезнее:

above_zero = my_filter(bool, seq)
only_odd = my_filter(is_odd, seq)
only_even = my_filter(is_even, seq)

Заметьте, одна функция и делает уже много чего. Вообще-то, она должна быть ленивой, делаем:

def my_filter(pred, seq):
    for x in seq:
        if pred(x):
            yield x

Вы заметили, что мы удалили код, а стало только лучше? Это лишь начало, скоро мы будем писать функции только по праздникам. Вот смотрите:

my_filter = filter

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


Частичное применение

Это процесс фиксации части аргументов функции, который создает другую функцию, меньшей арности. В переводе на наш это functools.partial.

filter_bool = partial(filter, bool)
filter_odd = partial(filter, is_odd)
filter_even = partial(filter, is_even)

Я понимаю, что это все азы ФП, но хочу отметить, что мы не написали ничего нового: мы взяли уже готовые функции и сделали другие. Основа новых — очень маленькие, простые, легкотестируемые функции, мы можем без опаски использовать их для создания более сложных.


Композирование

Такой простой, крутой и нужной штуки в python нет. Ее можно написать самостоятельно, но хотелось бы вменяемой сишной имплементации 🙁

def compose(*fns):
    init, *rest = reversed(fns)
    return lambda *a, **kw: reduce(lambda a, b: b(a), rest, init(*a, **kw))

Теперь мы можем делать всякие штуки (выполнение идет справа налево):

mapv = compose(list, map)
filterv = compose(list, filter)

Это прежние версии map и filter из второй версии python. Теперь, если вам понадобится неленивый map, вы можете вызвать mapv. Или по старинке писать чуть больше кода. Каждый раз.

Функции compose и partial прекрасны тем, что позволяют переиспользовать уже готовые, оттестированные функции. Но самое главное, если вы понимаете преимущество данного подхода, то со временем станете сразу писать их готовыми к композиции.

Это очень важный момент — функция должна решать одну простую задачу, тогда:


  • она будет маленькой
  • ее будет проще тестировать
  • легко композировать
  • просто читать и менять
  • тяжело сломать

Пример

Задача: дропнуть None из последовательности.
Решение по старинке (чаще всего даже не пишется в виде функции):

no_none = (x for x in seq if x is not None)

Обратите внимание: без разницы как называется переменная в выражении. Это настолько неважно, что большинство программистов тупо пишут x, чтобы не заморачиваться. Все пишут этот бессмысленный код раз за разом. Каждый цензура раз: for, in, if и несколько раз x — потому что для компрехеншена нужен scope и у него есть свой синтаксис. Мы пишем: на каждую итерацию цикла присвоить переменной значение. И оно присваивается, и проверяется условие.

Мы каждый раз пишем этот бойлерплейт и пишем тесты на этот бойлерплейт. Зачем?

Давайте перепишем:

from operator import is_
from itertools import filterfalse
from functools import partial

is_none = partial(is_, None)
filter_none = partial(filterfalse, is_none) 

# Использование
no_none = filter_none(seq)

# Переиспользование
all_none = compose(all, partial(map, is_none))

Все. Никакого лишнего кода. Мне приятно такое читать, потому что этот код (no_none = filter_none(seq)) очень простой. То, как работает это функция, мне нужно прочитать ровно один раз за все время в проекте. Компрехеншен вам придется читать каждый раз, чтобы точно понять что оно делает. Ну или засуньте ее в функцию, без разницы, но не забудьте про тесты.


Пример 2

Довольно частая задача получить значения по ключу из массива словарей.

names = (x['name'] for x in users)

Кстати, работает очень быстро, но мы снова написали кучу ненужной фигни. Перепишем, чтобы работало еще быстрее:

from operator import itemgetter

def pluck(key, seq):
    return map(itemgetter(key), seq)

# Использование
names = pluck('name', users)

А как часто мы это будем делать?

get_names = partial(pluck, 'name')
get_ages = partial(pluck, 'age')

# Сложнее
get_names_ages = partial(pluck, ('name', 'age'))
users_by_age = compose(dict, get_names_ages)

ages = users_by_ages(users)  # {x['name']: x['age'] for x in users}

А если у нас объекты? Пф, параметризируй это:

from operator import itemgetter, attrgetter

def plucker(getter, key, seq):
    return map(getter(key), seq)

pluck = partial(plucker, itemgetter)
apluck = partial(plucker, attrgetter)

# Использование
names = pluck('name', users)  # (x['name'] for x in users)
object_names = apluck('name', users)  # (x.name for x in users)

# Геттеры умеют сразу таплы данных
object_data = apluck(('name', 'age', 'gender'), users)  # ((x.name, x.age, x.gender) for x in users)

Пример 3

Представим себе простой генератор:

def dumb_gen(seq):
    result = []
    for x in seq:
        # здесь что-то проиcходит
        result.append(x)
    return result

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

Правильным решением будут использование filter(pred, seq) или map(func, seq), но иногда нужно сделать что-то сложнее, т.е. генератор написать действительно нужно. А если результат всегда нужен в виде списка или тапла? Да легко:

@post_processing(list)
def dumb_gen(seq):
    for x in seq:
        ...
        yield x

Это параметрический декоратор, работает он так:

result = post_processing(list)(dumb_gen)(seq)

Т.е. результатом первого вызова будет новая функция, которая примет функцию в качестве аргумента и вернет другую функцию. Звучит сложнее, чем есть:

def post_processing(post):
    return lambda func: compose(post, func)

Обратите внимание, я использовал уже существующую compose. Результат — новая функция, которую никто не писал.
А теперь стихи:

post_list = post_processing(list)
post_tuple = post_processing(tuple)
post_set = post_processing(set)
post_dict = post_processing(dict)
join_comma = post_processing(', '.join)

@post_list
def dumb_gen(pred, seq):
    for x in seq:
        ...
        yield x

Куча новых функций по цене одной! И я убрал бойлерплейт, функция стала меньше и намного симпатичнее.


Итог

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


  • пишите чистые функции, они обеспечат стабильность программы
  • пишите функции высшего порядка, код станет намного компактнее и надежнее
  • композируйте, декорируйте, частично применяйте, переиспользуйте код
  • используйте сишные либы, они дадут скорости вашему софту

Как только вы напишете свой набор инструментов, новый код будет создаваться со знанием того, что у вас есть штука, которая может решить часть задачи. А значит софт будет меньше и проще.


С чего начать?


  • обязательно ознакомьтесь с itertools, functools, operator, collections, в особенности с примерами в конце
  • загляните в документацию funcy или другой фпшной либы, почитайте исходный код
  • напишите свой funcy, весь он сразу вам не нужен, но опыт очень пригодится

Credits

В моем случае, использование ФП началось со знакомства с clojure — это штука капитально выворачивает мозги, настоятельно рекомендую посмотреть хотя бы видосы на ютубе.

Clojure как-то так устроен, что вам приходится писать проще, без привычных нам вещей: без переменных, без любимого стиля "романа", где сначала мы раскрываем личность героя, потом пускаемся в его сердечные проблемы. В clojure вам приходится думать %) В нем только базовые типы данных и "отсутствие синтаксиса" (с). И эту "простую" концепцию, оказывается, можно портировать в python.


UPD

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

Учим функциональное программирование в Python за 10 минут / Habr


Фото: Chris Ried

В этой статье вы поймете, что такое функциональная парадигма и как пользоваться функциональным программированием в Python. Также узнаете об абстракции списков и других способах абстракции (list comprehensions).

Функциональная парадигма


В императивной парадигме вы пишете программу путем указания последовательности действий, которые позже выполняются. В это время состояния (прим. переводчика: переменных, массивов, и т.д.) меняются. Например, пусть переменная А хранит значение 5, позже Вы изменяете значение этой переменной. Вы пользуетесь переменными так, что их значения меняются.

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

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

a = 3
def some_func():
    global a
    a = 5

some_func()
print(a)

Результат исполнения этого кода равен 5. В функциональном программировании изменение переменных находится под запретом и изменение функциями чего-либо за своими границами тоже. Все что может функция это посчитать/обработать что-то и вернуть результат.

Сейчас, Вы возможно думаете: «Никаких переменных, никаких побочных эффектов? Почему это хорошо?» Действительно хороший вопрос.

Если функция была вызвана дважды с одинаковыми параметрами, очевидно она возвратит тот же результат. Если Вы изучали что-то о математических функциях, то Вы оцените эту возможность. Это называется прозрачностью ссылок или чистотой языка программирования (referential transparency). Поскольку функции не имеют побочных эффектов, если Вы разрабатываете программу для обсчетов, Вы можете ускорить процесс выполнения. Если программе известно, что func(2) равняется 3, мы можем это запомнить. Это предотвращает повторный вызов функции, когда мы уже знаем результат.

Обычно, в функциональном программировании, циклы не используются. Используется рекурсия. Рекурсия это математический концепт, по сути, он означает «скармливание что-то самому себе». В рекурсивной функции, сама функция вызывает себя же в роли под-функции. Приведем пример рекурсивной функции в Python:

def factorial_recursive(n):
    # Base case: 1! = 1 # Основной случай
    if n == 1:
        return 1

    # Recursive case: n! = n * (n-1)! # Тут случается рекурсия
    else:
        return n * factorial_recursive(n-1)

Некоторые языки программирования ленивы. Это означает, что они все обсчитывают в последний момент. Допустим если в коде должно выполниться 2+2, функциональная программа посчитает результат только тогда, когда будет нужен результат. Узнаем про ленивости Python немного позже.

Map


Чтобы понять map, нужно сначала разобраться с итерируемыми контейнерами. Это такой контейнер, по которому можно «пробежаться». Это зачастую списки или массивы, но в Python таких контейнеров много. Можно даже создать свой контейнер, введя магические методы. Эти методы как API, которе помогают объектам стать более питоническими. Таких методов нужно 2, чтобы сделать объект итерируемым:

class Counter:
    def __init__(self, low, high):
        # set class attributes inside the magic method __init__
        # for "inistalise"
        # Задаем атрибуты класса для инициализации
        self.current = low
        self.high = high

    def __iter__(self):
        # first magic method to make this object iterable
        # Первый магический метод
        return self
    
    def __next__(self):
        # second magic method
        # Второй магический метод
        if self.current > self.high:
            raise StopIteration
        else:
            self.current += 1
return self.current - 1

Первый магический метод это "___iter__" или dunder (дважды выделенный подчеркиваниями ) iter возвращает итерируемый объект, это часто используется в начале цикла. Dunder next (__next__) возвращает следующий объект.

Проверим это:

for c in Counter(3, 8):
print(c)

Результат исполнения:

3
4
5
6
7
8

В Python, итератор это объект, который имеет только метод __iter__. Это означает, что Вы можете получить доступ к месту ячеек объекта (контейнера), но не сможете «пройтись» по ним. Некоторые объекты имеют только чудный метод __next__, без волшебного метода __iter__, например set (о нём позже). В этой статье мы покроем все, что касается итерируемых объектов.

Теперь нам известно, что такое итерируемый объект, вернемся к функции map. Эта функция позволяет нам применить действие какой-либо другой функции к каждому элементу в итерируемом контейнере. Мы хотим применить функцию к каждому элементу в списке, это возможно почти для всех итерируемых контейнеров. Map, принимает два аргумента: функцию, которую нужно применить, и контейнер (список, и т.п.).

map(function, iterable)

Допустим у нас есть список с такими элементами:

[1, 2, 3, 4, 5]

И мы хотим возвести в квадрат каждый элемент, это можно сделать так:

x = [1, 2, 3, 4, 5]
def square(num):
    return num*num

print(list(map(square, x)))

Функциональные функции в Python ленивы. Если мы не добавим «list()», функция будет хранить описание контейнера (списка), а не сам список. Нам непосредственно нужно сообщить Pythonону, чтоб он конвертировал это в список.

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

Писать функции, например, «square(num)» это нормально, но не совсем правильно. Нам нужно объявить целую функцию, чтобы только использовать её в map? Можно упростить это дело путём введения (анонимных) lambda функций.

Lambda выражения


Lambda выражения это функции в одну строчку, например, вот lambda выражение, которое возводит в квадрат полученное число:

square = lambda x: x * x

И, запустим это:

>>> square(3)
9

Я вас слышу. «Брендон, где аргументы? Что это вообще такое? Это не похоже на функцию.»

Да, это может сбить с толку, но это можно объяснить. В этой строчке мы присваиваем кое-что переменной «square». Эта часть:

lambda x: x * x

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

Чтобы наша программа приняла вид one-line, нужно сделать так:

x = [1, 2, 3, 4, 5]
print(list(map(lambda num: num * num, x)))

Значит, в lambda выражениях, аргументы слева, а действия над ними справа. Это немного неопрятно, никто не отрицает. Истина в том, что в этом что-то есть, писать такой функциональный код. Также, очень круто конвертировать функции в однострочные.

Reduce


Reduce это функция, которая превращает итерируемый контейнер в что-то одно. То есть производятся вычисления, которые превращают список в одно число. Это выглядит так:

reduce(function, list)

Мы можем (и часто будем) использовать lambda функции в роли function аргумента.

Если мы хотим перемножить все числа в списке, это можно сделать так:

product = 1
x = [1, 2, 3, 4]
for num in x:
product = product * num

А с reduce это будет выглядеть так:
from functools import reduce

product = reduce((lambda x, y: x * y),[1, 2, 3, 4])

Результат будет один и тот же, но код короче и со знаниями функционального программирования использовать это точнее.

Filter


Функция filter принимает итерируемый контейнер и фильтрует его по заданному правилу (тоже функция).

Обычно она принимает на вход функцию и список. Позже применяет к каждому элементу в списке функцию, если функция возвращает True — ничего не происходит, а если False — элемент из списка удаляется.

Синтаксис:

filter(function, list)

Посмотрим на пример без использования filter:
x = range(-5, 5)
new_list = []

for num in x:
    if num < 0:
new_list.append(num)

Вместе с filter:
x = range(-5, 5)
all_less_than_zero = list(filter(lambda num: num < 0, x))

Функции высшего порядка


Функции высшего порядка могут принимать функции как аргументы и возвращать их. Простой пример будет выглядеть так:

def summation(nums):
    return sum(nums)

def action(func, numbers):
    return func(numbers)

print(action(summation, [1, 2, 3]))

# Output is 6 # Вывод 6

Или пример ещё проще, это:
def rtnBrandon():
    return "brandon"
def rtnJohn():
    return "john"

def rtnPerson():
    age = int(input("What's your age?"))

    if age == 21:
        return rtnBrandon()
    else:
        return rtnJohn()

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

Все функции в Python это объекты первого класса. Объект первого класса определён как таковой, что соответствует одному или более таких параметров:

  • Создает рабочий цикл
  • Присваивается к переменной или элементу в структуре данных
  • Передается как аргумент функции
  • Возвращается как результат выполнения функции

Так что все функции в Python это объекты первого класса, и могут использоваться как функции высшего порядка.

Частичное применение


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

def power(base, exponent):
  return base ** exponent

Теперь нам нужно создать отдельную функцию для возведения в квадрат, и вычислить его используя функцию power:
def square(base):
  return power(base, 2)

Это работает, но что если мы хотим возвести число в куб? Или в 4-ую степень? Предстоит писать такие функции вечно? Конечно, можно. Но программисты ленивы. Если Вы повторяете одну и ту же вещь несколько раз, наверняка есть способ сделать это быстрее и перестать делать повторения. Здесь можно использовать частичное применение. Посмотрим на пример функции power c использованием частичного применения:
from functools import partial

square = partial(power, exponent=2)
print(square(2))

# output is 4 # вывод 4

Разве не круто? Мы можем вызвать функцию которой нужно 2 аргумента, используя только 1, и указав каким будет второй самостоятельно.

Также можно использовать цикл, чтобы сымитировать функцию power которая будет работать с кубами и вплоть до 1000-ой степени.

from functools import partial

powers = []
for x in range(2, 1001):
  powers.append(partial(power, exponent = x))

print(powers[0](3))
# output is 9 # вывод 9

Функциональное программирование не соответствует питоническим канонам


Вы могли заметить, что много вещей которые мы хотим сделать в функциональном программировании вертятся вокруг списков. Помимо функции reduce и частичного применения, все функции которые Вы видели генерируют списки. Гвидо (создатель Python`a) не любит функциональные вещи в Python`e, так как у Python`a есть свой метод создания списков.

Если Вы напишете “import this” в консоли, то получите:
>>> import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one — and preferably only one — obvious way to do it.
Although that way may not be obvious at first unless you’re Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea — let’s do more of those!

Это Python-Дзен. Это стих о том что значит быть питонистом. Часть которая нас интересует это:

There should be one  —  and preferably only one  —  obvious way to do it.

Должен быть только один — и предпочтительно только один — очевидный путь что-то сделать

В Python`e, map и filter могут делать то же самое что и абстракция списков (ссылка). Это нарушает одно из правил Python-Дзена, так что эта часть функционального программирования не «питоническая».

Следующие о чём стоит поговорить это lambda-функция. В Python`e, lambda-функция это нормальная функция. И по сути это синтаксический сахар. Обе эти части делают одно и то же:


 foo = lambda a: 2

 def foo(a):
   return 2

Стандартная функция может всё то же, что и lambda-функция, но не наоборот. Lambda-функция не может того же, что может обычная.

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

Абстракция списков


Я уже сказал, что все что можно сделать с помощью map и filter, можно сделать при помощи абстракции списков. В этой части мы это обсудим.

Абстракция списков это способ создания списков в Python. Синтаксис:

[function for item in iterable]

Давайте возведем в квадрат каждый элемент списка, пример:
print([x * x for x in [1, 2, 3, 4]])

Ладно, мы можем увидеть как применить функцию к каждому элементу списка. Каким же образом мы вертимся вокруг filter? Глянем на этот код:
x = range(-5, 5)

all_less_than_zero = list(filter(lambda num: num < 0, x))
print(all_less_than_zero)

А теперь используем абстракцию списков:
x = range(-5, 5)

all_less_than_zero = [num for num in x if num < 0]

Абстракция списков поддерживает условные выражения такого вида. Вам уже не нужно применять миллион функций чтобы что-либо получить. По сути, если Вы пытаетесь что-то сделать со списком, есть вероятность того, что чище и легче этого можно достичь с абстракцией списков.

Что если мы хотим возвести в квадрат каждый элемент списка, который ниже нуля. С lambda-функцией, map и filter это будет выглядеть так:

x = range(-5, 5)

all_less_than_zero = list(map(lambda num: num * num, list(filter(lambda num: num < 0, x))))

Эта запись не рациональна и не очень проста. С использованием абстракции списков это будет выглядеть так:
x = range(-5, 5)

all_less_than_zero = [num * num for num in x if num < 0]

Абстракция списков это хорошо только, как ни странно, для списков. Map и filter работают для каждого итерируемого контейнера, так что же не так?.. Да, можно использовать абстракцию для каждого итерируемого контейнера который Вы встретите.

Другие абстракции


Можно применить абстракцию для каждого итерируемого контейнера.

Каждый итерируемый контейнер может быть создан при помощи абстракции. Начиная с версии 2.7, можно даже создать словарь (хеш-таблицу).

Если что-то итерируемый контейнер, то это что-то можно сгенерировать. Давайте посмотрим на последний пример используя set. Если Вы не знаете что такое set, то посмотрите эту статью написанную тоже мной. Если вкратце:

  • Set это контейнер элементов, элементы в нём не повторяются
  • Порядок не важен
# taken from page 87, chapter 3 of Fluent Python by Luciano Ramalho
# Взято из книги Fluent Python, стр. 87, п. 3

>>> from unicodedata import name
>>> {chr(i) for i in range(32, 256) if 'SIGN' in name(chr(i), '')}
{'×', '¥', '°', '£', '', '#', '¬', '%', 'µ', '>', '¤', '±', '¶', '§', '<', '=', '', '$', '÷', '¢', '+'}

Как Вы могли заметить set, как и словарь (dictionary) использует фигурные скобки. Python действительно умный. Он догадается используете Вы абстракцию словаря или же абстракцию set`a, основываясь на том, задаёте ли Вы дополнительные параметры для словаря или нет. Если Вы хотите узнать больше об абстракциях, прочтите эту. Если же об абстракциях и генерировании, то эту.

Итог


Функциональное программирование прекрасно. Функциональный код может быть как чистым, так и не очень. Некоторые хардкорщики-питонисты не принимают функциональную парадигму в Python`e. Вы должны использовать то, что Вы хотите и то, что вам подходит.

Страничка автора.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *