Python описание – Основы языка программирования Python за 10 минут / Habr

Основы языка программирования Python за 10 минут / Habr

На сайте Poromenos’ Stuff была
опубликована статья, в которой, в сжатой форме,
рассказывают об основах языка Python. Я предлагаю вам перевод этой статьи. Перевод не дословный. Я постарался подробнее объяснить некоторые моменты, которые могут быть непонятны.

Если вы собрались изучать язык Python, но не можете найти подходящего руководства, то эта
статья вам очень пригодится! За короткое время, вы сможете познакомиться с
основами языка Python. Хотя эта статья часто опирается
на то, что вы уже имеете опыт программирования, но, я надеюсь, даже новичкам
этот материал будет полезен. Внимательно прочитайте каждый параграф. В связи с
сжатостью материала, некоторые темы рассмотрены поверхностно, но содержат весь
необходимый метриал.

Основные свойства

Python не требует явного объявления переменных, является регистро-зависим (переменная var не эквивалентна переменной Var или VAR — это три разные переменные) объектно-ориентированным языком.

Синтаксис

Во первых стоит отметить интересную особенность Python. Он не содержит операторных скобок (begin..end в pascal или {..}в Си), вместо этого

блоки выделяются отступами: пробелами или табуляцией, а вход в блок из операторов осуществляется двоеточием. Однострочные комментарии начинаются со знака фунта «#», многострочные — начинаются и заканчиваются тремя двойными кавычками «»»»».
Чтобы присвоить значение пременной используется знак «=», а для сравнения —
«==». Для увеличения значения переменной, или добавления к строке используется оператор «+=», а для уменьшения — «-=». Все эти операции могут взаимодействовать с большинством типов, в том числе со строками. Например

>>> myvar = 3
>>> myvar += 2
>>> myvar -= 1
«»«Это многострочный комментарий
Строки заключенные в три двойные кавычки игнорируются»»»
>>> mystring = «Hello»
>>> mystring += » world.»
>>> print mystring
Hello world.
# Следующая строка меняет
значения переменных местами. (Всего одна строка!)

>>> myvar, mystring = mystring, myvar

Структуры данных

Python содержит такие структуры данных как списки (lists), кортежи (tuples) и словари (dictionaries). Списки — похожи на одномерные массивы (но вы можете использовать Список включающий списки — многомерный массив), кортежи — неизменяемые списки, словари — тоже списки, но индексы могут быть любого типа, а не только числовыми. «Массивы» в Python могут содержать данные любого типа, то есть в одном массиве может могут находиться числовые, строковые и другие типы данных. Массивы начинаются с индекса 0, а последний элемент можно получить по индексу -1 Вы можете присваивать переменным функции и использовать их соответственно.

>>> sample = [1, [«another», «list»], («a», «tuple»)] #Список состоит из целого числа, другого списка и кортежа
>>> mylist = [«List item 1», 2, 3.14] #Этот список содержит строку, целое и дробное число
>>> mylist[0] = «List item 1 again» #Изменяем первый (нулевой) элемент листа mylist
>>> mylist[-1] = 3.14 #Изменяем последний элемент листа
>>> mydict = {«Key 1»: «Value 1», 2: 3, «pi»: 3.14} #Создаем словарь, с числовыми и целочисленным индексами
>>> mydict[«pi»] = 3.15 #Изменяем элемент словаря под индексом «pi».
>>> mytuple = (1, 2, 3) #Задаем кортеж
>>> myfunction = len #Python позволяет таким образом объявлять синонимы функции
>>> print myfunction(list)
3

Вы можете использовать часть массива, задавая первый и последний индекс через двоеточие «:». В таком случае вы получите часть массива, от первого индекса до второго не включительно. Если не указан первый элемент, то отсчет начинается с начала массива, а если не указан последний — то масив считывается до последнего элемента. Отрицательные значения определяют положение элемента с конца. Например:

>>> mylist = [«List item 1», 2, 3.14]
>>> print mylist[:] #Считываются все элементы массива
[‘List item 1’, 2, 3.1400000000000001]
>>> print mylist[0:2] #Считываются нулевой и первый элемент массива.
[‘List item 1’, 2]
>>> print mylist[-3:-1] #Считываются элементы от нулевого (-3) до второго (-1) (не включительно)
[‘List item 1’, 2]
>>> print mylist[1:] #Считываются элементы от первого, до последнего
[2, 3.14]

Строки

Строки в Python обособляются кавычками двойными «»» или одинарными «’». Внутри двойных ковычек могут присутствовать одинарные или наоборот. К примеру строка «Он сказал ‘привет’!» будет выведена на экран как «Он сказал ‘привет’!». Если нужно использовать строку из несколько строчек, то эту строку надо начинать и заканчивать тремя двойными кавычками «»»»». Вы можете подставить в шаблон строки элементы из кортежа или словаря. Знак процента «%» между строкой и кортежем, заменяет в строке символы «%s» на элемент кортежа. Словари позволяют вставлять в строку элемент под заданным индексом. Для этого надо использовать в строке конструкцию «%(индекс)s». В этом случае вместо «%(индекс)s» будет подставлено значение словаря под заданным индексом.

>>>print «Name: %s\nNumber: %s\nString: %s» % (myclass.name, 3, 3 * «-«)
Name: Poromenos
Number: 3
String: —  
strString = «»«Этот текст расположен
на нескольких строках»»»
 
>>> print «This %(verb)s a %(noun)s.» % {«noun»: «test», «verb»: «is»}
This is a test.

Операторы

Операторы while, if, for составляют операторы перемещения. Здесь нет аналога оператора select, так что придется обходиться

if. В операторе for происходит сравнение переменной и списка. Чтобы получить список цифр до числа <number> — используйте функцию range(<number>). Вот пример использования операторов

rangelist = range(10) #Получаем список из десяти цифр (от 0 до 9)
>>> print rangelist
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for number in rangelist: #Пока переменная number (которая каждый раз увеличивается на единицу) входит в список…
# Проверяем входит ли переменная
# numbers в кортеж чисел (3, 4, 7, 9)
if number in (3, 4, 7, 9): #Если переменная number входит в кортеж (3, 4, 7, 9)…
# Операция «break» обеспечивает
# выход из цикла в любой момент
break
else:
# «continue» осуществляет «прокрутку»
# цикла. Здесь это не требуется, так как после этой операции
# в любом случае программа переходит опять к обработке цикла
continue

else:
# «else» указывать необязательно. Условие выполняется
# если цикл не был прерван при помощи «break».
pass # Ничего не делать
 
if rangelist[1] == 2:
print «The second item (lists are 0-based) is 2»
elif rangelist[1] == 3:
print «The second item (lists are 0-based) is 3»
else:
print «Dunno»
 
while rangelist[1] == 1:
pass

Функции

Для объявления функции служит ключевое слово «def». Аргументы функции задаются в скобках после названия функции. Можно задавать необязательные аргументы, присваивая им значение по умолчанию. Функции могут возвращать кортежи, в таком случае надо писать возвращаемые значения через запятую. Ключевое слово «lambda» служит для объявления элементарных функций .

# arg2 и arg3 — необязательые аргументы, принимают значение объявленное по умолчни,

# если не задать им другое значение при вызове функци.
def myfunction(arg1, arg2 = 100, arg3 = «test»):
return arg3, arg2, arg1
#Функция вызывается со значением первого аргумента — «Argument 1», второго — по умолчанию, и третьего — «Named argument».
>>>ret1, ret2, ret3 = myfunction(«Argument 1», arg3 = «Named argument»)
# ret1, ret2 и ret3 принимают значения «Named argument», 100, «Argument 1» соответственно
>>> print ret1, ret2, ret3
Named argument 100 Argument 1
 
# Следующая запись эквивалентна def f(x): return x + 1
functionvar = lambda x: x + 1
>>> print functionvar(1)
2

Классы

Язык Python ограничен в множественном наследовании в классах. Внутренние переменные и внутренние методы классов начинаются с двух знаков нижнего подчеркивания «__» (например «__myprivatevar»). Мы можем также присвоить значение переменной класса извне. Пример:

class Myclass:
common = 10
def __init__(self):
self.myvariable = 3
def myfunction(self, arg1, arg2):
return self.myvariable
 
# Здесь мы объявили класс Myclass. Функция __init__ вызывается автоматически при инициализации классов.
>>> classinstance = Myclass() # Мы инициализировали класс и переменная myvariable приобрела значение 3 как заявлено в методе инициализации
>>> classinstance.myfunction(1, 2) #Метод myfunction класса Myclass возвращает значение переменной myvariable
3
# Переменная common объявлена во всех классах
>>> classinstance2 = Myclass()
>>> classinstance.common
10
>>> classinstance2.common
10
# Поэтому, если мы изменим ее значение в классе Myclass изменятся

# и ее значения в объектах, инициализированных классом Myclass
>>> Myclass.common = 30
>>> classinstance.common
30
>>> classinstance2.common
30
# А здесь мы не изменяем переменную класса. Вместо этого
# мы объявляем оную в объекте и присваиваем ей новое значение
>>> classinstance.common = 10
>>> classinstance.common
10
>>> classinstance2.common
30
>>> Myclass.common = 50
# Теперь изменение переменной класса не коснется
# переменных объектов этого класса
>>> classinstance.common
10
>>> classinstance2.common
50
 
# Следующий класс является наследником класса Myclass
# наследуя его свойства и методы, ктому же класс может
# наследоваться из нескольких классов, в этом случае запись
# такая: class Otherclass(Myclass1, Myclass2, MyclassN)
class Otherclass(Myclass):
def __init__(self, arg1):
self.myvariable = 3
print arg1
 
>>> classinstance = Otherclass(«hello»)
hello
>>> classinstance.myfunction(1, 2)
3
# Этот класс не имеет совйтсва test, но мы можем
# объявить такую переменную для объекта. Причем
# tэта переменная будет членом только classinstance.
>>> classinstance.test = 10
>>> classinstance.test
10

Исключения

Исключения в Python имеют структуру try—except [exceptionname]:

def somefunction():
try:
# Деление на ноль вызывает ошибку
10 / 0
except ZeroDivisionError:
# Но программа не «Выполняет недопустимую операцию»
# А обрабатывает блок исключения соответствующий ошибке «ZeroDivisionError»
print «Oops, invalid.»
 
>>> fnexcept()
Oops, invalid.

Импорт

Внешние библиотеки можно подключить процедурой «import [libname]», где [libname] — название подключаемой библиотеки. Вы так же можете использовать команду «from [libname] import [funcname]», чтобы вы могли использовать функцию [funcname] из библиотеки [libname]

import random #Импортируем библиотеку «random»
from time import clock #И заодно функцию «clock» из библиотеки «time»
 
randomint = random.randint(1, 100)
>>> print randomint
64

Работа с файловой системой

Python имеет много встроенных библиотек. В этом примере мы попробуем сохранить в бинарном файле структуру списка, прочитать ее и сохраним строку в текстовом файле. Для преобразования структуры данных мы будем использовать стандартную библиотеку «pickle»

import pickle
mylist = [«This», «is», 4, 13327]
# Откроем файл C:\binary.dat для записи. Символ «r»
# предотвращает замену специальных сиволов (таких как \n, \t, \b и др.).
myfile = file(r«C:\binary.dat», «w»)
pickle.dump(mylist, myfile)
myfile.close()
 
myfile = file(r«C:\text.txt», «w»)
myfile.write(«This is a sample string»)
myfile.close()
 
myfile = file(r«C:\text.txt»)
>>> print myfile.read()
‘This is a sample string’
myfile.close()
 
# Открываем файл для чтения
myfile = file(r«C:\binary.dat»)
loadedlist = pickle.load(myfile)
myfile.close()
>>> print loadedlist
[‘This’, ‘is’, 4, 13327]

Особенности

• Условия могут комбинироваться. 1 < a < 3 выполняется тогда, когда а больше 1, но меньше 3.
• Используйте операцию «del» чтобы очищать переменные или элементы массива.
• Python предлагает большие возможности для работы со списками. Вы можете использовать операторы объявлении структуры списка. Оператор for позволяет задавать элементы списка в определенной последовательности, а if — позволяет выбирать элементы по условию.

>>> lst1 = [1, 2, 3]
>>> lst2 = [3, 4, 5]
>>> print [x * y for x in lst1 for y in lst2]
[3, 4, 5, 6, 8, 10, 9, 12, 15]
>>> print [x for x in lst1 if 4 > x > 1]
[2, 3]
# Оператор «any» возвращает true, если хотя
# бы одно из условий, входящих в него, выполняется.
>>> any(i % 3 for i in [3, 3, 4, 4, 3])
True
# Следующая процедура подсчитывает количество
# подходящих элементов в списке
>>> sum(1 for i in [3, 3, 4, 4, 3] if i == 3)
3
>>> del lst1[0]
>>> print lst1
[2, 3]
>>> del lst1

• Глобальные переменные объявляются вне функций и могут быть прочитанны без каких либо объявлений. Но если вам необходимо изменить значение глобальной переменной из функции, то вам необходимо объявить ее в начале функции ключевым словом «global», если вы этого не сделаете, то Python объявит переменную, доступную только для этой функции.

number = 5
 
def myfunc():
# Выводит 5
print number
 
def anotherfunc():
# Это вызывает исключение, поскольку глобальная апеременная
# не была вызванна из функции. Python в этом случае создает
# одноименную переменную внутри этой функции и доступную
# только для операторов этой функции.
print number
number = 3
 
def yetanotherfunc():
global number
# И только из этой функции значение переменной изменяется.
number = 3

Эпилог

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

Преимущества Python

• Скорость выполнения программ написанных на Python очень высока. Это связанно с тем, что основные библиотеки Python
  написаны на C++ и выполнение задач занимает меньше времени, чем на других языках высокого уровня.
• В связи с этим вы можете писать свои собственные модули для Python на C или C++
• В стандартныx библиотеках Python вы можете найти средства для работы с электронной почтой, протоколами
  Интернета, FTP, HTTP, базами данных, и пр.
• Скрипты, написанные при помощи Python выполняются на большинстве современных ОС. Такая переносимость обеспечивает Python применение в самых различных областях.
• Python подходит для любых решений в области программирования, будь то офисные программы, вэб-приложения, GUI-приложения и т.д.
• Над разработкой Python трудились тысячи энтузиастов со всего мира. Поддержкой современных технологий в стандартных библиотеках мы можем быть обязаны именно тому, что Python был открыт для всех желающих.

habr.com

Основы 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
И так далее.

habr.com

Введение в функциональное программирование на Python / Habr

Рассуждая о функциональном программировании, люди часто начинают выдавать кучу «функциональных» характеристик. Неизменяемые данные, функции первого класса и оптимизация хвостовой рекурсии. Это свойства языка, помогающие писать функциональные программы. Они упоминают мапирование, каррирование и использование функций высшего порядка. Это приёмы программирования, использующиеся для написания функционального кода. Они упоминают распараллеливание, ленивые вычисления и детерменизм. Это преимущества функциональных программ.

Забейте. Функциональный код отличается одним свойством: отсутствием побочных эффектов. Он не полагается на данные вне текущей функции, и не меняет данные, находящиеся вне функции. Все остальные «свойства» можно вывести из этого.

Нефункциональная функция:

a = 0
def increment1():
    global a
    a += 1

Функциональная функция:

def increment2(a):
    return a + 1

Вместо проходов по списку используйте map и reduce

Map

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

Простой map, принимающий список имён и возвращающий список длин:

name_lengths = map(len, ['Маша', 'Петя', 'Вася'])

print name_lengths
# => [4, 4, 3]

Этот map возводит в квадрат каждый элемент:

squares = map(lambda x: x * x, [0, 1, 2, 3, 4])

print squares
# => [0, 1, 4, 9, 16]

Он не принимает именованную функцию, а берёт анонимную, определённую через lambda. Параметры lambda определены слева от двоеточия. Тело функции – справа. Результат возвращается неявным образом.

Нефункциональный код в следующем примере принимает список имён и заменяет их случайными прозвищами.

import random

names = ['Маша', 'Петя', 'Вася']
code_names = ['Шпунтик', 'Винтик', 'Фунтик']

for i in range(len(names)):
    names[i] = random.choice(code_names)

print names
# => ['Шпунтик', 'Винтик', 'Шпунтик']

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

Перепишем это через map:

import random

names = ['Маша', 'Петя', 'Вася']

secret_names = map(lambda x: random.choice(['Шпунтик', 'Винтик', 'Фунтик']), names)

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

names = ['Маша', 'Петя', 'Вася']

for i in range(len(names)):
    names[i] = hash(names[i])

print names
# => [6306819796133686941, 8135353348168144921, -1228887169324443034]

Моё решение:

names = ['Маша', 'Петя', 'Вася']

secret_names = map(hash, names)

Reduce

Reduce принимает функцию и набор пунктов. Возвращает значение, получаемое комбинированием всех пунктов.

Пример простого reduce. Возвращает сумму всех пунктов в наборе:

sum = reduce(lambda a, x: a + x, [0, 1, 2, 3, 4])

print sum
# => 10

x – текущий пункт, а – аккумулятор. Это значение, которое возвращает выполнение lambda на предыдущем пункте. reduce() перебирает все значения, и запускает для каждого lambda на текущих значениях а и х, и возвращает результат в а для следующей итерации.

А чему равно а в первой итерации? Оно равно первому элементу коллекции, и reduce() начинает работать со второго элемента. То есть, первый х будет равен второму предмету набора.

Следующий пример считает, как часто слово «капитан» встречается в списке строк:

sentences = ['капитан джек воробей',
             'капитан дальнего плавания',
             'ваша лодка готова, капитан']

cap_count = 0
for sentence in sentences:
    cap_count += sentence.count('капитан')

print cap_count
# => 3

Тот же код с использованием reduce:

sentences = ['капитан джек воробей',
             'капитан дальнего плавания',
             'ваша лодка готова, капитан']

cap_count = reduce(lambda a, x: a + x.count('капитан'),
                   sentences,
                   0)

А откуда здесь берётся начальное значение а? Оно не может быть вычислено из количества повторений в первой строке. Поэтому оно задаётся как третий аргумент функции reduce().

Почему map и reduce лучше?

Во-первых, они обычно укладываются в одну строку.

Во-вторых, важные части итерации,– коллекция, операция и возвращаемое значение,– всегда находятся в одном месте map и reduce.

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

В-четвёртых, map и reduce – элементарные операции. Вместо построчного чтения циклов читателю проще воспринимать map и reduce, встроенные в сложные алгоритмы.

В-пятых, у них есть много друзей, позволяющих полезное, слегка изменённое поведение этих функций. Например, filter, all, any и find.

Упражнение 2: перепишите следующий код, используя map, reduce и filter. Filter принимает функцию и коллекцию. Возвращает коллекцию тех вещей, для которых функция возвращает True.

people = [{'имя': 'Маша', 'рост': 160},
    {' рост ': 'Саша', ' рост ': 80},
    {'name': 'Паша'}]

height_total = 0
height_count = 0
for person in people:
    if 'рост' in person:
        height_total += person[' рост ']
        height_count += 1

if height_count > 0:
    average_height = height_total / height_count

    print average_height
    # => 120

Моё решение:

people = [{'имя': 'Маша', 'рост': 160},
    {' рост ': 'Саша', ' рост ': 80},
    {'name': 'Паша'}]

heights = map(lambda x: x['рост'],
              filter(lambda x: 'рост' in x, people))

if len(heights) > 0:
    from operator import add
    average_height = reduce(add, heights) / len(heights)

Пишите декларативно, а не императивно

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

Примеры вывода:

 -
 - -
 - -

 - -
 - -
 - - -

 - - -
 - -
 - - -

 - - - -
 - - -
 - - - -

 - - - -
 - - - -
 - - - - -

Текст программы:

from random import random

time = 5
car_positions = [1, 1, 1]

while time:
    # decrease time
    time -= 1

    print ''
    for i in range(len(car_positions)):
        # move car
        if random() > 0.3:
            car_positions[i] += 1

        # draw car
        print '-' * car_positions[i]

Код императивен. Функциональная версия была бы декларативной – она бы описывала, что нужно сделать, а не то, как это надо сделать.

Используем функции

Декларативности можно достичь, вставляя код в функции:

from random import random

def move_cars():
    for i, _ in enumerate(car_positions):
        if random() > 0.3:
            car_positions[i] += 1

def draw_car(car_position):
    print '-' * car_position

def run_step_of_race():
    global time
    time -= 1
    move_cars()

def draw():
    print ''
    for car_position in car_positions:
        draw_car(car_position)

time = 5
car_positions = [1, 1, 1]

while time:
    run_step_of_race()
    draw()

Для понимания программы читатель просматривает основной цикл. «Если осталось время, пройдём один шаг гонки и выведем результат. Снова проверим время». Если читателю надо будет разобраться, как работает шаг гонки, он сможет прочесть его код отдельно.

Комментарии не нужны, код объясняет сам себя.

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

Вот функциональная версия этой программы:

from random import random

def move_cars(car_positions):
    return map(lambda x: x + 1 if random() > 0.3 else x,
               car_positions)

def output_car(car_position):
    return '-' * car_position

def run_step_of_race(state):
    return {'time': state['time'] - 1,
            'car_positions': move_cars(state['car_positions'])}

def draw(state):
    print ''
    print '\n'.join(map(output_car, state['car_positions']))

def race(state):
    draw(state)
    if state['time']:
        race(run_step_of_race(state))

race({'time': 5,
      'car_positions': [1, 1, 1]})

Теперь код разбит на функциональные функции. Тому есть три признака. Первый – нет расшаренных переменных. time и car_positions передаются прямиком в race(). Второе – функции принимают параметры. Третье – переменные не меняются внутри функций, все значения возвращаются. Каждый раз, когда run_step_of_race() проделывает следующий шаг, он передаётся опять в следующий.

Вот вам две функции zero() и one():

def zero(s):
    if s[0] == "0":
        return s[1:]

def one(s):
    if s[0] == "1":
        return s[1:]

zero() принимает строку s. Если первый символ – 0, то возвращает остаток строки. Если нет – тогда None. one() делает то же самое, если первый символ – 1.

Представим функцию rule_sequence(). Она принимает строку и список из функций-правил, состоящий из функций zero и one. Она вызывает первое правило, передавая ему строку. Если не возвращено None, то берёт возвращённое значение и вызывает следующее правило. И так далее. Если возвращается None, rule_sequence() останавливается и возвращает None. Иначе – значение последнего правила.

Примеры входных и выходных данных:

print rule_sequence('0101', [zero, one, zero])
# => 1

print rule_sequence('0101', [zero, zero])
# => None

Императивная версия rule_sequence():

def rule_sequence(s, rules):
    for rule in rules:
        s = rule(s)
        if s == None:
            break

    return s

Упражнение 3. Этот код использует цикл. Перепишите его в декларативном виде с использованием рекурсии.

Моё решение:

def rule_sequence(s, rules):
    if s == None or not rules:
        return s
    else:
        return rule_sequence(rules[0](s), rules[1:])

Используйте конвейеры (pipelines)

Теперь перепишем другой вид циклов при помощи приёма под названием конвейер.

Следующий цикл изменяет словари, содержащие имя, неправильную страну происхождения и статус некоторых групп.

bands = [{'name': 'sunset rubdown', 'country': 'UK', 'active': False},
         {'name': 'women', 'country': 'Germany', 'active': False},
         {'name': 'a silver mt. zion', 'country': 'Spain', 'active': True}]

def format_bands(bands):
    for band in bands:
        band['country'] = 'Canada'
        band['name'] = band['name'].replace('.', '')
        band['name'] = band['name'].title()

format_bands(bands)

print bands
# => [{'name': 'Sunset Rubdown', 'active': False, 'country': 'Canada'},
#     {'name': 'Women', 'active': False, 'country': 'Canada' },
#     {'name': 'A Silver Mt Zion', 'active': True, 'country': 'Canada'}]

Название функции «format» слишком общее. И вообще, код вызывает некоторое беспокойство. В одном цикле происходят три разные вещи. Значение ключа ‘country’ меняется на ‘Canada’. Убираются точки и первая буква имени меняется на заглавную. Сложно понять, что код должен делать, и сложно сказать, делает ли он это. Его тяжело использовать, тестировать и распараллеливать.

Сравните:

print pipeline_each(bands, [set_canada_as_country,
                            strip_punctuation_from_name,
                            capitalize_names])

Всё просто. Вспомогательные функции выглядят функциональными, потому что они связаны в цепочку. Выход предыдущей – вход следующей. Их просто проверить, использовать повторно, проверять и распараллеливать.

pipeline_each() перебирает группы по одной, и передаёт их функциям преобразования, вроде set_canada_as_country(). После применения функции ко всем группам, pipeline_each() делает из них список и передаёт следующей.

Посмотрим на функции преобразования.

def assoc(_d, key, value):
    from copy import deepcopy
    d = deepcopy(_d)
    d[key] = value
    return d

def set_canada_as_country(band):
    return assoc(band, 'country', "Canada")

def strip_punctuation_from_name(band):
    return assoc(band, 'name', band['name'].replace('.', ''))

def capitalize_names(band):
    return assoc(band, 'name', band['name'].title())

Каждая связывает ключ группы с новым значением. Без изменения оригинальных данных это тяжело сделать, поэтому мы решаем это с помощью assoc(). Она использует deepcopy() для создания копии переданного словаря. Каждая функция преобразовывает копию и возвращает эту копию.

Всё вроде как нормально. Оригиналы данных защищены от изменений. Но в коде есть два потенциальных места для изменений данных. В strip_punctuation_from_name() создаётся имя без точек через вызов calling replace() с оригинальным именем. В capitalize_names() создаётся имя с первой прописной буквой на основе title() и оригинального имени. Если replace и time не функциональны, то и strip_punctuation_from_name() с capitalize_names() не функциональны.

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

Такой контраст между строками и словарями (их изменяемостью) в Python демонстрирует преимущества языков типа Clojure. Там программисту не надо думать, не изменит ли он данные. Не изменит.

Упражнение 4. Попробуйте сделать функцию pipeline_each. Задумайтесь над последовательностью операций. Группы – в массиве, передаются по одной для первой функции преобразования. Затем полученный массив передаётся по одной штучке для второй функции, и так далее.

Моё решение:

def pipeline_each(data, fns):
    return reduce(lambda a, x: map(x, a),
                  fns,
                  data)

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

set_canada_as_country = call(lambda x: 'Canada', 'country')
strip_punctuation_from_name = call(lambda x: x.replace('.', ''), 'name')
capitalize_names = call(str.title, 'name')

print pipeline_each(bands, [set_canada_as_country,
                            strip_punctuation_from_name,
                            capitalize_names])

Или, жертвуя читаемостью:

print pipeline_each(bands, [call(lambda x: 'Canada', 'country'),
                            call(lambda x: x.replace('.', ''), 'name'),
                            call(str.title, 'name')])

Код для call():

def assoc(_d, key, value):
    from copy import deepcopy
    d = deepcopy(_d)
    d[key] = value
    return d

def call(fn, key):
    def apply_fn(record):
        return assoc(record, key, fn(record.get(key)))
    return apply_fn

Что тут у нас происходит.

Один. call – функция высшего порядка, т.к. принимает другую функцию как аргумент и возвращает функцию.

Два. apply_fn() похожа на функции преобразования. Получает запись (группу). Ищет значение record[key]. Вызывает fn. Присваивает результат в копию записи и возвращает её.

Три. call сам ничего не делает. Всю работу делает apply_fn(). В примере использования pipeline_each(), один экземпляр apply_fn() задаёт ‘country’ значение ‘Canada’. Другой – делает первую букву прописной.

Четыре. При выполнении экземпляра apply_fn() функции fn и key не будут доступны в области видимости. Это не аргументы apply_fn() и не локальные переменные. Но доступ к ним будет. При определении функции она сохраняет ссылки на переменные, которые она замыкает – те, что были определены снаружи функции, и используются внутри. При запуске функции переменные ищутся среди локальных, затем среди аргументов, а затем среди ссылок на замкнутые. Там и найдутся fn и key.

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

Молодцом. Замыкания, функции высшего порядка и область видимости – всё в нескольких параграфах. Можно и чайку с печеньками выпить.

Остаётся ещё одна обработка данных групп. Убрать всё, кроме имени и страны. Функция extract_name_and_country():

def extract_name_and_country(band):
    plucked_band = {}
    plucked_band['name'] = band['name']
    plucked_band['country'] = band['country']
    return plucked_band

print pipeline_each(bands, [call(lambda x: 'Canada', 'country'),
                            call(lambda x: x.replace('.', ''), 'name'),
                            call(str.title, 'name'),
                            extract_name_and_country])

# => [{'name': 'Sunset Rubdown', 'country': 'Canada'},
#     {'name': 'Women', 'country': 'Canada'},
#     {'name': 'A Silver Mt Zion', 'country': 'Canada'}]

extract_name_and_country() можно было бы написать в обобщённом виде под названием pluck(). Использовалась бы она так:

print pipeline_each(bands, [call(lambda x: 'Canada', 'country'),
                            call(lambda x: x.replace('.', ''), 'name'),
                            call(str.title, 'name'),
                            pluck(['name', 'country'])])

Упражнение 5. pluck принимает список ключей, которые надо извлечь из записей. Попробуйте её написать. Это буде функция высшего порядка.

Моё решение:

def pluck(keys):
    def pluck_fn(record):
        return reduce(lambda a, x: assoc(a, x, record[x]),
                      keys,
                      {})
    return pluck_fn

И что теперь?

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

Вспомните про Машу, Петю и Васю. Превратите итерации по спискам в map и reduces.

Вспомните гонки. Разбейте код на функции, и сделайте их функциональными. Превратите цикл в рекурсию.

Вспомните про группы. Превратите последовательность операций в конвейер.

habr.com

R и Python — достойные соперники? / Издательский дом «Питер» corporate blog / Habr

Всем доброй пятницы, дорогие читатели!

В истории компьютерной редакции издательства «Питер» найдется немного столь успешных книг, как «Программируем на Python» Майкла Доусона и не больше таких противоречивых тем, как изумительный язык R, прочно закрепившийся в числе бестселлерных тем «Амазона». В настоящее время мы договариваемся с правообладателями о новой замечательной книге по Python, но в то же время хотели проверить общественное мнение о R — целесообразно ли издавать новые книги об этом элитарном языке для гуру большой статистики, либо Python легко его одолеет, не то что Аполлона?

Добро пожаловать под кат!

Языки Python и R спорят за звание «наилучшего» инструмента для работы с данными, и у обоих соперников есть свои достоинства и недостатки. Выбор того или иного языка зависит от конкретной ситуации, издержек на обучение, а также от того, какие еще распространенные инструменты требуются для решения задачи

Студенты часто интересуются, каким языком – R и/или Python лучше пользоваться при решении повседневных задач, связанных с анализом данных. Я обычно предлагаю интерактивные руководства по R, но уточняю, что в каждом конкретном случае выбор зависит от типа поставленной задачи, данные по которой требуется проанализировать.

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

В этой статье будут рассмотрены важнейшие отличия между языками R и Python, а также рассказано, какое место они оба занимают в мире изучения данных и статистики. Если вы предпочитаете инфографику, посмотрите разработку ”Data Science Wars: R vs Python”.

Знакомство с R

Росс Айхэка и Роберт Джентлмэн создали свободный язык R в 1995 году как свободную реализацию языка программирования S. Они стремились разработать язык, который обеспечивал бы более качественный и понятный подход к анализу данных, статистике и графическим моделям. На первых порах R использовался преимущественно в академической и научно-исследовательской среде, но сравнительно недавно стал проникать и в мир больших корпораций. Поэтому R — один из наиболее бурно развивающихся статистических языков, используемых в корпоративной практике.

Одно из основных достоинств R — огромное сообщество разработчиков, занимающихся поддержкой языка в почтовых рассылках, службе пользовательской документации и в очень активной группе на Stack Overflow. Также существует CRAN, гигантский репозиторий рекомендованных пакетов R, в разработке которых могут участвовать все желающие. Эти пакеты представляют собой коллекцию функций и данных R, они обеспечивают мгновенный доступ к новейшим приемам и функционалу, избавляя программиста от необходимости все изобретать самостоятельно.

Наконец, если вы – опытный разработчик, то вам, вероятно, не составит труда быстро освоить R. Начинающему программисту, возможно, придется туго, поскольку кривая обучения R очень крутая. К счастью, в настоящее время существует множество отличных учебных ресурсов по R.

Знакомство с Python

Язык Python был создан Гвидо ван Россумом в 1991 году. В этом языке делается акцент на производительности и удобочитаемости кода. Среди программистов, желающих погрузиться в анализ данных и пользоваться статистическими приемами, немало активных пользователей Python, применяющих этот язык именно в статистической сфере. Чем активнее вы углубляетесь в среду технарей, тем больше вам, по всей вероятности, будет нравиться Python. Этот гибкий язык отлично подходит для всего новаторского. Учитывая его простоту и удобочитаемость, кривая обучения для этого языка сравнительно пологая.

Как и в R, в Python есть пакеты. PyPi — это список пакетов Python, в нем содержатся библиотеки, дополнять которые может любой пользователь. Как и R, Python обладает большим сообществом разработчиков, но оно несколько неоднородное, поскольку Python — универсальный язык. Тем не менее, именно наука о данных стремительно занимает все более внушительные позиции во вселенной Python: ожидания растут, одно за другим появляются новые приложения по работе с данными.

R и Python: Общие показатели

В Сети можно встретить массу количественных сравнений распространенности и популярности R и Python. Хотя такие показатели и позволяют уверенно сориентироваться в том, как эти два языка развиваются в общем контексте информатики, сравнить их напрямую нелегко. Основная причина заключается в том, что сфера использования R ограничена наукой о данных. Python, в свою очередь, будучи универсальным языком, широко применятся во многих сферах, например, в веб-разработке. Поэтому рейтинги зачастую искажаются в пользу Python, тогда как зарплаты оказываются существенно выше у специалистов по R.

Когда и как использовать R?

R обычно применяется в тех случаях, когда для анализа данных требуются выделенные вычислительные мощности или отдельные сервера. R отлично подходит для исследовательской работы, удобен практически при любом варианте анализа данных, поскольку в языке R существует масса пакетов и готовые тесты, обеспечивающие нужный инструментарий для быстрого старта. R даже может быть элементом решения в области больших данных.
Приступая к работе с R, целесообразно для начала установить замечательную IDE RStudio. Затем рекомендую ознакомиться со следующими популярными пакетами:

• dplyr, plyr и data.table, упрощающие манипуляции с пакетами,
• stringr для работы со строками,
• zoo для работы с регулярными и иррегулярными временными последовательностями,
• ggvis, lattice и ggplot2 для визуализации данных и
• caret для машинного обучения

Когда и как использовать Python?

Python пригодится в случаях, когда задачи, связанные с анализом данных, вплетаются в работу веб-приложений, или если статистический код требуется инкорпорировать в рабочую базу данных. Python, будучи полнофункциональным языком программирования, отлично подходит для реализации алгоритмов с их последующим практическим использованием. Еще недавно пакеты для анализа данных на Python находились в зачаточном состоянии, что представляло определенную проблему, но в последние годы ситуация значительно улучшилась. Обязательно установите NumPy /SciPy (научные вычисления) и pandas (манипуляции с данными), чтобы приспособить Python для анализа данных. Кроме того, обратите внимание на библиотеку matplotlib для создания графики и scikit-learn для машинного обучения.

В отличие от R, для Python не существует ярко выраженной “выигрышной” IDE. Желательно ознакомиться со Spyder, IPython Notebook и Rodeo и выбрать ту, которая лучше всего вам подходит.

R и Python: доли в сегменте науки о данных

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

Несмотря на вышеприведенную инфографику, есть основания полагать, что все больше специалистов переходят с R на Python. Более того, растет доля тех программистов, которые владеют обоими языками и по мере необходимости используют то один, то другой. Именно такую тактику я рекомендую моим студентам.

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

R: Плюсы и минусы

Плюс: Картинка бывает информативнее тысячи слов
Если данные визуализировать, то они зачастую становятся выразительнее и понятнее, чем голые числа. Язык R просто создан для визуализаций. Обязательно ознакомьтесь с пакетами для визуализации ggplot2, ggvis, googleVis и rCharts.

Плюс: экосистема R
R обладает богатой экосистемой ультрасовременных пакетов и располагает активным сообществом. Пакеты доступны в репозиториях CRAN, BioConductor и Github. Все пакеты R можно просмотреть по адресу Rdocumentation.

Плюс: R – лингва-франка науки о данных
Язык R разрабатывался статистиками для статистиков. Они могут обмениваться идеями и концепциями при помощи кода и пакетов R, кроме того, для погружения в эту тему им не обязательно обладать базовыми знаниями по информатике. Кроме того, язык все шире распространяется в неакадемической среде.

Плюс/минус: R — медленный язык
R создавался, чтобы облегчить работу статистикам, а не вашему компьютеру. R может казаться медленным из-за некачественно написанного кода, однако существует множество пакетов, повышающих производительность R: pqR, renjin и FastR, Riposte и многие другие.

Минус: R сложен в изучении
Кривая обучения языку R нетривиальна, особенно если вы беретесь за статистический анализ, опираясь на графический интерфейс. Даже поиск пакетов может занять много времени, если вам это в новинку.

Python: плюсы и минусы

Плюс: IPython Notebook
Инструмент IPython Notebook облегчает работу с Python и данными. Не составит труда использовать такой блокнот вместе с коллегами, причем им даже не придется ничего устанавливать. В таком случае резко снижаются издержки, связанные с организацией кода, файлами вывода и заметок. Вы сможете уделить больше времени полезной работе.

Плюс: универсальный язык
Python – универсальный язык, простой и интуитивно-понятный. Кривая обучения у него сравнительно пологая, на этом языке вы сможете быстрее писать программы. Короче говоря, на код тратится мало времени, а на разные интересности – много!

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

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

Плюс/Минус: Визуализации
Возможность визуализации – важный критерий при подборе софта для анализа данных. Хотя в Python и есть приятные библиотеки для визуализации, например, Seaborn, Bokeh и Pygal, выбор может быть излишне велик. Более того, по сравнению с R, визуализация на Python устроена гораздо сложнее, а ее результаты порой не слишком наглядны.

Минус: Python играет на чужом поле
Python — конкурент R. Но в нем нет альтернатив для сотен важнейших пакетов R. Пусть Python и успешно догоняет, неясно, будут ли люди ради него отказываться от R?

А победителя…

Определяете вы! Как специалист по данным, вы должны сами подобрать себе язык для работы. Постарайтесь ответить на следующие вопросы:

1. Какие проблемы вам требуется решать?
2. Во что вам обойдется изучение нового языка?
3. Какие инструменты активно используются в вашей профессиональной сфере?
4. Какие альтернативы существуют для этих инструментов?

Удачи!

habr.com

Где применяется Python: 3 основных назначения языка | Статья

Прежде чем начать изучать тот или иной язык программирования, люди обычно задумываются, как потом смогут применить свои знания и навыки на практике. Что касается Python, этот язык общего назначения пригодится во множестве различных сфер. Разработчик и основатель стартапа CS Dojo Ек Суги рассказал о трёх самых частых способах использования Python.

Читать далее

Фреймворки, основанные на Python, такие как Django и Flask, в последнее время приобрели широкую популярность среди веб-разработчиков. Эти фреймворки позволяют создавать серверный код (backend-код) на Python, который выполняется на сервере, в отличие от frontend-кода, исполняемого на пользовательских устройствах и в браузерах.

Для чего нужны веб-фреймворки

Веб-фреймворки упрощают разработку серверной логики: обработку URL, обращение к базам данных, создание HTML-файлов, которые видят в браузерах пользователи.

Какие фреймворки для веб-разработки лучше использовать

Два наиболее популярных веб-фреймворка для  Python — Django и Flask. Их рекомендуется использовать начинающим разработчикам.

В чём разница между Django и Flask

Отличную статью в ответ на этот вопрос подготовил Гарет Дуайер.

Основные различия:

• Flask — простой и гибкий фреймворк с очень подробными настройками. Пользователь может сам решать, как реализовывать те или иные вещи.
• Django предоставляет полный функционал для разработки приложений прямо «из коробки»: встроенный интерфейс администратора, API доступа к базам данных, ORM, и структуру каталогов для приложений и проектов.

Лучше воспользоваться:

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

Таким образом, Flask предпочтительнее использовать новичкам, потому что этот фреймворк имеет не настолько богатый функционал, а также тем, кому важна возможность настроить его по своему усмотрению. Кроме того, благодаря своей гибкости Flask больше, чем Django, подойдёт для разработки REST API. С другой стороны, если требуется создать простой продукт, быстрее это получится сделать на Django.

Что такое машинное обучение

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

На второй она должна распознать стол.

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

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

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

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

• системы распознавания лиц,
• системы распознавания голоса,
• рекомендательные системы сайтов вроде YouTube, Amazon или Netflix.

Самые широко известные алгоритмы машинного обучения:

• нейронные сети,
• глубокое обучение,
• метод опорных векторов,
• «случайный лес».

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

Python для машинного обучения

Для Python есть популярные библиотеки и фреймворки машинного обучения. Две самые крупные из них — scikit-learn и TensorFlow. В scikit-learn встроены некоторые общеизвестные алгоритмы машинного обучения, о которых шла речь выше. TensorFlow — более низкоуровневая библиотека, которая позволяет строить пользовательские алгоритмы.

Как изучать машинное обучение

Чтобы изучить основы этой технологии, можно пройти курсы Стэнфордского университета или Калифорнийского технологического института. Но для понимания некоторого материала понадобятся базовые знания матанализа и линейной алгебры.

Далее полученную информацию нужно закрепить на сайте Kaggle. Здесь можно соревноваться с другими разработчиками в создании лучшего алгоритма машинного обучения для различных задач. Сайт также предлагает полезные самоучители для начинающих.

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

На диаграмме видно, что в заданное воскресенье покупатели мужского пола приобрели более 400 единиц товара, а женского — около 350. У специалиста может быть несколько предположений, почему возник этот разрыв.

Одно из очевидных объяснений — продукт более востребован среди мужчин, чем женщин. Другая возможная причина — недостаточно большая выборка, а разницу можно списать на случайность. Третий вариант — по какой-то причине мужчины склонны больше покупать этот продукт только в воскресенье. Чтобы понять, какое из объяснений истинно, можно нарисовать ещё одну диаграмму.

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

Но если бы диаграмма выглядела так,

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

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

Анализ и визуализация данных на Python

Matplotlib — одна из наиболее распространённых библиотек для визуализации данных. Начинать лучше с неё потому, что она проста, а также потому, что на ней основаны некоторые другие библиотеки, например, seaborn. Поэтому знание Matplotlib поможет в будущем освоить и их.

Как изучать анализ и визуализацию данных на Python

В первую очередь нужно выучить основы. Ек Суги предлагает собственное вводное видео в анализ и визуализацию данных на Python и Matplotlib на YouTube, а также полный практический курс на образовательной платформе Pluralsight, который можно получить бесплатно после подписки на 10-дневный пробный период на сайте. После этого полезно изучить основы статистики, например, на Coursera и Khan Academy.

Что такое написание скриптов

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

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

Python и встраиваемые приложения

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

Python и компьютерные игры

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

Например, можно начинать с Unity на C# — это одна из самых общеизвестных сред разработки компьютерных игр. Она позволяет создавать межплатформенные игры для Windows, Mac, iOS и Android.

Python и десктопные приложения

Десктопные приложения можно разрабатывать на Python с помощью Tkinter, но это также не самый частый выбор: разработчики приложений для ПК предпочитают языки Java, C#, и C++. В последнее время некоторые компании для этого начали применять и JavaScript. Например, десктопное приложение Slack построено во фреймворке Electron, использующем JavaScript. Этот язык даёт возможность повторно использовать код из веб-версии приложения, если такая имеется.

Python 3 или Python 2

Лучше выбрать Python 3, потому что на сегодняшний день это более современная и более востребованная версия языка.

dev.by

Где перспективно и адекватно использовать Python / Habr

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

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

Что ты можешь сделать на Питоне

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

Микроконтроллеры (весьма сомнительно)

Хотя Андрей Власовских на прошедшем PYCON Russia 2017 в своей фирменной манере с энтузиазмом рассказывал о том, как программировать микроконтроллеры на таком инструменте, как MicroPython, а Кирилл Борисов даже предлагал изучить некоторую зарубежную литературу, ситуация в общем никакая.

Список микроконтроллеров, которые поддерживаются Python, стремится к нулю, коммерческая эффективность и наличие предложений по работе практическая нулевая. С учетом того, что есть более традиционные способы инструменты программирования, пока какая-то большая компания не вложится в этом направление, тут делать нечего.

Девопс (адекватно)

Анализ рынка показывает, что примерно треть всех вакансий, где упоминается Python, относятся к сфере DevOpsa. Однако Python идет не основным инструментом, а той технологией, которую знать желательно. Это связано с тем, что Python практичности полностью сместил Perl для Linux, и неплохо так подвинул Bash в области написания крупных скрипов и более крупных серверных компонентов. Также к этому добавляется то, что интерфейс многих тулзов принимает Python в качестве языка сценариев.

Если вы хотите развиваться в сфере Девопса, то знание Питон вам будет большим плюсом, все остальные проходят эту сферу стороной.

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

Тестирование (адекватно)

Хотя главным инструментом автоматизации тестирования является кровавая Java, которая имеет огромный набор фреймворков и готовых решений, порой небольшие компании используют Python для полноценного тестирования, либо написания сценариев для тулзов, типа Яндекс.Танк с его BFG.

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

Вакансий под тестирование примерно также треть от общей массы, часто в вакансиях указывают знание и Python и Java одновременно.

Desktop development (сомнительно)

В настоящий момент язык Python имеет 5 кросc-платформенных инструментов, которые позволяют писать «полноценные» приложения под Windows/Linux/Mac

• Tkinter
• PyQt
• PyGTK
• WxPython
• Kivy (Условно)

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

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

Что касается внутренних инструментов, то использование небольших GUI-приложений применяется, но искать целенаправленно Desktop Python разработчиков не будут.

Кто же хочется заняться этой сферой более полно, прошу к Игорю Новикову, который нашел неплохой способ сшить Франкенштейна с помощью абстракционного слоя – ссылка

Mobile Development (весьма сомнительно)

Все плохо, в качестве pet проектов можно использовать Kivy, для реальной разработки весьма сомнительно, вакансий на Kivy нет.

Т.е. как, я лично разговаривал с рядом людей, которые имели свой веб-проект на Python и для захвата большой аудитории писали приложения на Kivy, и у них его даже использовали, но это имеет вид «Программист пишет то, на чем хочет».

Машинное обучение и Data science (адекватно и перспективно)

Это одна из самых хайповы областей современного IT-мира, где используется Python в качестве инструмента апробации. Python имеет ряд удобных библиотек машинного обучения и научных расчетов: Pandas, NumPy, SciPy, Scikit-Learn, которые позволяют достаточно быстро построить рабочие модели. И они на самом деле неплохо работают.

Что касается использования, то Python используется в качестве инструмента апробации, либо на небольших задачах. Если проект большой, то обычно модель пишут на Java/Scala/C++, а специалист по обучению уже выступает в качестве консультанта/аналитика.

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

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

Тем, кто хочет быстренько пощупать данное направление, советую прочитать книгу: «Vvedenie_v_mashinnoe_obuchenie_s_pomoschyu_Python_-_A_Myuller_S_Gvido_2017» — есть на торрентах, читается быстро, представление дает хорошее.

Веб-скрапинг (возможно, но сомнительно)

Питон имеет три вещи, которые делают его весьма эффективными в области веб-скраппинга, бибиотеку Requests, beautifulsoup и АПИ для Selenium. Если сюда подключиться библиотеки для компьютерного зрения и Машинное обучение, то получаются весьма эффективные инструменты.

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

Область интересная, но денег в ней мало.

Компьютерное зрение (сомнительно)

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

GameDev (сомнительно)

Практически в каждом обсуждении разработки игры на Python приводят в качестве примера eve online и WarGaming. Однако в первом случае используется stateless python, а во втором случае все ограничивается языком написания сценариев.

Что же касается реального использования, то у вас появляется три движка Kivy, PyGame, Panda3D, если первые два больше подходят для пет-проектов, то третий реально использовался на боевых проектах неплохого качества, правда эти проекты были 2004 года. Что как бы намекает, что использование проверенных движков на других языках типа Unity или Game Maker выглядит более убедительно.

Однако незаметно сюда крадется движок Ren’Py, который внезапно стал лучшим движков для написания визуальных романов (страдальческих историй для девочек), которые неплохо окупаются даже в рамках РФ. Серия «7 демонологов Петра Великого», тому доказательство.

Вакансий в GameDev для питона естественно нет, но деньги на «стартапе» поднять можно при должной сноровке. Но надежней взять другой язык и проверенные движки.

Веб-разработка (адекватно и перспективно)

Питон входит в тройку языков (Python, PHP, Ruby), которые обладают развитыми экосистемами быстрой разработки веб-проектов адекватного качества. Ключевыми платформами тут являются:

• Django (монолитный синхронный фреймворк)
• Flask (микро синхронный фреймворк)
• Tornado (монолитный асинхронный фреймворк)
• Twisted (монолитный асинхронный фреймворк)
• Aiohttp (микро асинхронных фреймворк)

В настоящий момент большую часть рынка занимает фреймворк Django, но с приходом идей микросервисов постепенно обороты стал набирать Flask. Что касается асинхронности, то тут все сложно, так как Tornado и Twisted признаны устаревшими (хотя на них работают многие компании, тот же Тиньков), а aiohttp весьма сырой, и его использование ставится под большим вопросом.

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

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

Выводы об использовании питона

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

2) Наиболее перспективными выглядят сферы веб-разработки и машинного обучения (аналитики), которые явно выделяют питон на фоне его конкурентов в виде PHP и Ruby. И если вы хотите изучить питон, то вам желательно сосредоточится именно на этих сферах и не тратить свое время на что-то другое. Под это есть вакансии, на этом можно построить стартап.

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

habr.com

Функции Print() в Python | Python

Функция print Python выводит заданные объекты на стандартное устройство вывода (экран) или отправляет их текстовым потоком в файл.

Полный синтаксис функции print():

print(*objects, sep=' ', end='n', file=sys.stdout, flush=False)

• objects – объект, который нужно вывести * обозначает, что объектов может быть несколько;
• sep – разделяет объекты. Значение по умолчанию: ‘ ‘;
• end – ставится после всех объектов;
• file – ожидается объект с методом write (string). Если значение не задано, для вывода объектов используется файл sys.stdout;
• flush – если задано значение True, поток принудительно сбрасывается в файл. Значение по умолчанию: False.

Примечание: sep, end, file и flush — это аргументы-ключевые слова. Если хотите воспользоваться аргументом sep, используйте:

print(*objects, sep = 'separator')

а не

print(*objects, 'separator')

Функция Python print не возвращает значений; возвращает None.

Пример 1: Как работает функция print() в Python?

print("Python — это весело.")

a = 5 
 # Передаётся два объекта 
 print("a =", a)

 b = a
 # Передаётся три объекта
 print('a =', a, '= b')

При запуске программы получаем:

Python — это весело.
a = 5
a = 5 = b

В примере, приведенном выше функции print Python 3, во всех трёх выражениях передаётся только параметр objects, поэтому:

• Используется разделитель ‘ ‘ — обратите внимание на пробел между двумя объектами в результатах вывода;
• В качестве параметра end используется ‘n’ (символ новой строки). Обратите внимание, что каждое выражение print выводится в новой строке;
• file — используется файл sys.stdout. Результат выводится на экран;
• Значение flush — False. Поток не сбрасывается принудительно.

Пример 2: print() с разделителем и параметром end

a = 5
print("a =", a, sep='00000', end='nnn')
print("a =", a, sep='0', end='')

При запуске программы получаем:

Мы передали в программу, пример которой приведен выше, параметры sep и end.

С помощью Python print без перевода строки также можно вывести объекты в файл, указав параметр file:

sourceFile = open('python.txt', 'w')
print("Круто же, правда?", file = sourceFile)
sourceFile.close()

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

В примере мы передали в параметр file объект sourceFile. Объект-строка ‘Круто же, правда?‘ записывается в файл python.txt (после чего можно открыть его текстовым редактором).

В конце исполнения программы файл закрывается методом close().

Данная публикация представляет собой перевод статьи «Python print()» , подготовленной дружной командой проекта Интернет-технологии.ру

www.internet-technologies.ru