Programming: Python:

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

• Интродюкшн.
• Обозначения.
• Где взять и как установить.
• Как записать и запустить программу.
• Как выглядит Питон-программа.
• Данные.
  • Числовые типы.
  • Тип-список.
• Операторы.
  • Числовые операторы.
  • Операторы над списками.
  • Логические операторы.
  • Операции сравнения.
  • Приоритеты операторов.
• Имена и пространства имен.
• Простые предложения языка.
• Составные предложения.
  • Условное предложение.
  • Цикл с параметром.
  • Цикл с предусловием.
  • Управление ходом выполнения циклов.
  • Определение функций.
• Некоторые полезные встроенные функции.
• Методы объекта "список".
• Модули math и cmath.
• Заключение.
• Что почитать?

Интродюкшн. Всякий программист наверняка, хотя бы раз, да сталкивался с задачей, связанной с обработкой "длинных" чисел. И наверняка, если сталкивался, разработал для себя подпрограммы для работы с такими числами (или скачал из Интернета %)). Но что делать, если вдруг понадобилось спрограмить что-нибудь эдакое, под рукой своих инструментов нет, а времени на написание программы не то, что в обрез, а в пол-обреза?
Если на компе есть интерпретатор Python - считай, спасен! У Питона - встроенная поддержка длинных чисел. А также комплексных. Кроме прочего, у него очень удобная и понятная манера оформления кода. Сейчас мы разберем основные моменты этого языка, и, по прочтении статьи, читатель сможет самостоятельно справиться с написанием своей вычислительной Python-программы.

Обозначения. Фигурные скобки {} в определениях используются для обозначения необязательных элементов.

Где взять и как установить. Скачать установочный пакет можно с официального сайта разработчиков языка . Новейшая версия на момент написания статьи - 2.3.4 (2.4 еще идет как alpha 1). Приятно то, что в пакет установки входит удобно структурированная и полная документация по программированию в Питоне, поэтому отдельно скачивать документацию не нужно.
Будем считать, что мы скачали установочный файл Python-2.3.4.exe для Win32. Смело его запускаем и следуем инструкциям.

Как записать и запустить программу. После установки, в меню кнопки "Пуск" в разделе "Программы" появится подменю "Python 2.0". Для запуска интерпретатора языка необходимо выбрать в это подменю пункт "IDLE (Python GUI)". В результате появится окно интерпретатора с заголовком "Python Shell". Это окно предназначено для интерактивного ввода команд. Каждая вводимая строка тут же и выполняется. Программу можно записать и в таком режиме, но это неудобно. Для того, чтобы работать с текстом программы в обычном режиме, необходимо нажать [Ctrl+N] - создать новое окно. В этом окне уже можно вводить текст программы как в обычном текстовом редакторе.

Примечание - А.Р.
Безусловно, текст Питон-программы можно записать в любом текстовом редакторе, но встроенный редактор IDLE удобен тем, что автоматически расставляет отступы и, при необходимости, увеличивает их. Кроме того, имеется очень полезная возможность закомментировать/раскомментировать выделенный код.

После набора текста программы запустить ее можно, нажав комбинацию [Ctrl+F5]. Не забудем сохранить программу перед запуском. Если же мы все-таки забудем, система напомнит об этом сама, т.к. запускать можно только программу, сохраненную в дисковом файле. При запуске программы активным становится окно Python Shell - то, которое мы открыли первым. Весь вывод программы и сообщения об ошибках будут отображаться в этом окне.

Как выглядит Питон-программа. Никаких особых обозначений для начала либо конца программы не нужно. Также нет никаких особых условий на порядок следования элементов программы (кроме здравого смысла, разумеется). Записываем инструкции в обычный текстовый файл - вот она и программа.

Данные. Всякий элемент данных в Питоне - это объект. Всякий объект имеет подпись (identity), тип и значение.
Подпись - штука постоянная и уникальная: с ее помощью можно однозначно определить, тождественны ли два объекта (такую проверку выполняет оператор is).
Тип - указывает на поддерживаемые объектом операции и его возможные значения. Тип объекта неизменяем. В Питоне типы переменных явно не указываются. Они определяются из контекста.

Примечание - А. Р.
Кажущееся изменение типа при присваивании объектов с разными типами на самом деле не является таковым: после присваивания x=y, x и y - один и тот же объект (точнее, x и y - ссылаются на один и тот же объект).

Все объекты делятся на изменяемые (mutable) и неизменяемые (immutable). Понятия "изменяемый" и "не-" являются довольно тонкими и связаны с возможностью изменения значения самого объекта после его создания. Изменяемость объекта однозначно определяется по его типу.

Далее мы рассмотрим числовые типы и тип-список, как наиболее востребованные при составлении вычислительных программ.

Числовые типы. Относятся к неизменяемым. Т.е. для объекта x такого типа нельзя написать, например, x.value = 3. Для изменения значения нужно писать x = 3 - присваивание объекта.

1. Целый (plain integer) тип.

Размер может варьироваться от 32 бит и выше - в зависимости от аппаратуры. В любом случае, выделяемая память - не меньше 32 бит. Диапазон допустимых значений: не уже -2147483648..2147483647.
Литералы, представляющие числа целого типа, могут задаваться в одной из трех систем счисления: 8-, 10-, и 16-ричной. Восьмеричный литерал начинается с 0 (012 = десятичное 10), десятичный с ненулевой десятичной цифры (12 = десятичное 12), а 16-ный - с 0x или 0X (0x12 = 0X12 = десятичное 18). Разумеется, все цифры литерала должны соответствовать выбранной системе счисления.
В случае 32-битового типа для 8- и 16-ричной систем допустимы литералы, обозначающие десятичные значения 0..4294967295, но значения, большие 2147483647, преобразовываются в отрицательное число (вычитанием 4294967296).

2. Длинный целый (long integer) тип.

Единственное ограничение на значения длинных целых чисел заключается в объеме доступной памяти. Не хило, правда?
Литералы, представляющие числа длинного целого типа, образуются приставкой к числу целого формата префикса l либо L (1L - длинное целое, хотя и вмещается в 32 бита).

3. Тип с плавающей точкой (floating point).

В Питоне представлен только числами с двойной точностью (уровня математического сопроцессора). Как написано в документации, "... нет причин усложнять язык двумя типами чисел с плавающей точкой". Диапазон допустимых значений зависит от аппаратуры.
Литералы, представляющие числа этого типа, задаются либо в записи через точку, либо в экспоненциальном виде (5.2e-1 = 5.2E-1 = 0.52, 5.2e+1 = 5.2E+1 = 52). Всегда трактуются как десятичные (03.5 - синтаксическая ошибка). Поддерживается сокращенная запись: 1. = 1 с плавающей точкой, .1 = 0.1. Показатель степени в экспоненциальной форме записи может быть только целым (1.2e+0.2 - синтаксическая ошибка).

4. Комплексный (complex) тип.

Представляет собой упорядоченную пару чисел с плавающей точкой. Все, сказанное выше о числах с плавающей точкой, верно и для обеих составляющих комплексного числа.
Литералов, представляющих комплексные числа, - нет. Есть только литералы, представляющие мнимые числа, т.е. комплексные числа с нулевой действительной частью. Такие литералы образуются с помощью префикса j либо J (12j = 12J = 0.0+12i).
Комплексные числа с ненулевой действительной частью образуются суммированием действительного числа и мнимого: (4+7j) - комплексное число.
Доступ (на чтение!) к действительной и мнимой компонентам комплексного числа z: z.real, z.imag.

Тип-список. Список - это изменяемая упорядоченная последовательность элементов (т.е. по форме - обычный массив) не обязательно одинакового типа. Обращение к i-му элементу списка A производится так: A[i]. Также можно задействовать несколько стоящих подряд элементов:

A[i:j]

- выбираются элементы с индексами i..(j-1)

A[i:]

- выбираются все элементы A, начиная с i-го

A[:j]

- выбираются все элементы A, заканчивая (j-1)-м

A[:]

- копия списка A

Операторы. Числовые операторы. Разберемся сначала, по каким правилам Питон выполняет приведение типов переменных к общему, если аргументы бинарного оператора имеют различные типы.

Итак, правила приведения числовых типов:

если один из аргументов - комплексное число

- второй приводится к комплексному типу

если оба аргумента - действительные и один из них - с плавающей точкой

- второй приводится к числу с плавающей точкой

если оба аргумента - действительные и целые, и один из них - длинный

- второй приводится к длинному целому

Арифметические

Унарные

+x

- оставляет x неизменным

-x

- изменяет знак x на противоположный

Бинарные

x+y, x-y, x*y

- сложение, вычитание, умножение

x/y

- деление. Если оба аргумента - целочисленные, результатом будет наименьшее целое число, не превышающее частного аргументов

x%y

- возвращает остаток от деления аргументов. Работает и для нецелых чисел (12.37%2.01 = 0.31)

x**y

- возведение x в степень y

Побитовые (применимы только к числам целых типов)

Унарные

~x

- побитовое инвертирование (отрицание) x

Бинарные

x&y

- булево умножение (логическое "И")

x|y

- булево сложение (логическое "ИЛИ")

x^y

- булево сложение по модулю 2 (логическое "ИСКЛЮЧАЮЩЕЕ ИЛИ")

Операторы сдвига (применимы только к числам целых типов)

x<<n (x>>n)

- сдвиг x на n (n≥0) бит влево (вправо)

Операторы над списками.

X+Y

- слияние списков

A*n, n*A

- слияние n копий списка A. Случай n<0 трактуется как и n=0 - в результате получаем пустой список

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

not x

- если x есть ложь, возвращается 0. В противном случае - 1

x or y

- если x есть истина, возвращается значение x. В противном случае возвращается значение y

x and y

- если x есть ложь, возвращается значение x. В противном случае возвращается значение y

Операции сравнения. Все сравнения возвращают 0 либо 1. Сравнения могут быть связаны в цепочку: a<b<c - то же самое, что и a<b and b<c (вот только, если b является выражением, тогда в первом случае оно вычисляется один раз, а во втором - два). Цепочки могут иметь произвольную длину и содержать любые операции. Раскрываются они, как в указанном примере, через логическое "И" всех сравнений, составляющих цепочку. Например, a<b>=c - то же, что и a<b and b>=c (смотрится несколько необычно, не правда ли?)
Перед числовым сравнением аргументы приводятся к общему типу.
Списки сравниваются путем поочередного сравнения элементов с одинаковыми индексами, начиная с 0.
Объекты разных типов всегда считаются неравными.

x<y

- меньше

x>y

- больше

x==y

- равно

x>=y

- больше либо равно

x<=y

- меньше либо равно

x<>y

- не равно

x!=y

- не равно

x is y

- проверка тождественности объектов. Негативная форма - is not: x is not y

x in A

- проверка, содержит ли правый аргумент-список значение-левый аргумент. Негативная форма - not in: x not in A

Приоритеты операторов (в порядке возрастания).

or
and
not
in, not in
is, is not
<, <=, >, >=, <>, !=, ==
|
^
&
<, >
+, -
*, /, %
**
+x, -x
~x

Имена и пространства имен. Имена переменных могут содержать символы 'a'..'z','A'..'Z','0'..'9','_'. Первый символ имени - буква или символ подчеркивания. Длина имен ограничения не имеет. Регистр символов - учитывается, т.е. var и Var - два разных имени.

В Питоне всякое имя может принадлежать локальному, глобальному либо встроенному (built-in) пространствам имен. Локальное пространство присутствует, например, в функциях. Глобальное - пространство основной программы. Поиск соответствия между именем и объектом производится в порядке Л - Г - В. Если, к примеру, в функции используется имя x, но в самой функции и ее формальных параметрах оно не определено, производится поиск в глобальном пространстве - все такие имена "видны" из тела функции. Но это "видение" дает доступ исключительно на чтение: присваивание приводит к появлению локального имени, а расширенное присваивание - к ошибке (о присваиваниях написано ниже). Для того, чтобы можно было использовать имена из глобального пространства в левой части присваиваний, необходимо в теле функции объявить желаемые имена переменных со словом global: global x,y,z.

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

Примеры.

x = 5
a = 4; b = a + 5

# Programma nichego ne delaet
i = 0 # Zadaem nachalnoe znachenie i

x = 2
a, b = -4, 5
z, y = [1,2,3], [4,7,[6,9]]
p, r, [s, u] = [1,2], 3, [4, [5,6,7]]
i, j = k, m = n = 0, 4

x, y = 1

- справа не хватает еще одного значения

a, b, c = 1, 2, 3, 4

- справа - лишнее значение

z, [y, p] = 1, 2, 4

- справа нужны скобки вокруг [2,4]

print 1
print 2,3,
print 4
print 5

Составные предложения. Они содержат другие предложения - простые и составные - и неким образом на них действуют либо управляют их выполнением.
Всякое составное предложение имеет такой вид: тип_предложения: сгруппированный_код

В общем случае, сгруппированный_код охватывает несколько строк кода, но можно записывать их и в одну строку, пользуясь разделителем ';'. Если сгруппированный_код охватывает несколько строк, все эти строки должны иметь одинаковый отступ слева - на 1 или более пробелов больший отступа для тип_предложения - таков принцип группирования многострочного кода в Питоне. Эта особенность языка позволяет сделать логическую структуру программы максимально прозрачной. Да и, вообще, - удобно таким образом оформлять код.

В качестве типов предложений мы рассмотрим if, for, while и определение функций.
Условное предложение.

if условное_выражение1: код1
{elif условное_выражение2: код2}
{elif условное_выражение3: код3}
{...}
{elif условное_выражениеN_1: кодN_1}
{else кодN}

if x>=0: x **= 0.5

if a>b: max = a
else: max = b

if a<x<b:
 r = b-a
 p = (a+b)/2
elif c<x<d: r = d-c; p = (c+d)/2
else: r = 0

if x==2: y = 3;
 z = 4
else: y = 2

for переменная in список_значений: тело_цикла
{else: код_завершения}

s = 0
for i in range(1,N+1):
 s += i
print "Sum = ",s

s = 0
for i in range(K,N+1,K)
 s += i
print "Sum = ",s

A = [1,2,3]
B = [4,5]
C = [6,7,8]
D = []
for i in [A,B,C]:
 D += i
print "A+B+C = ",D

while условное_выражение: тело_цикла
{else: код_завершения}

x, y = a, b
while x!=y:
 while x>y:
  x -= y
 x, y = y, x
print "NOD(",a,",",b,") = ",x

for i in [a,b,c]:
 if i==0:
  print "a*b*c = 0"
  break
else: print "a*b*c !=0"

s = 0
for i in A:
 if i==0: continue # na nol delit nelzya
 s += 1/i
print "Sum = ",s

i = 0
while 1:
 if not A[i]: break
 i += 1
print "A[",i,"]= 0"

m, i = 0, 0
while i<len(A):
 i += 1
 if A[i-1]==0: continue
 m += A[i-1]**2
print "|A| = ",m**0.5

def имя_функции (список_параметров): код_функции

def fact(n):
 k=1L # nachalnoe znachenie factoriala. Ono zhe - rezultat dlya n=0,1
 for m in range(2,n+1): k *= m
 return k
fact(4) = 24
fact(0) = 1
fact(21) = 51090942171709440000

def sumdig( n, base=10): # opredelyaem desyatichnuyu sistemu no umolchaniyu
 s = 0 # nachalnoe znachenie summiy
 while n:
  s += n % base # zanosim v summu ocherednuyu tsifru
  n /= base # perehod k sleduyuschey tsifre
 return s
sumdig(10,2) = 2
sumdig(38983) = 31
sumdig(87324,8) = 20
sumdig(173,3) = 5

def sum(*a):
 s = 0
 for i in a: s += i
 return s
sum(1,2,3,4,5) = 15
sum(-1,1,10,20,100) = 130

Некоторые полезные встроенные функции.

Числовые (работают на всех числовых типах)

abs(x)

- модуль x

pow(x,y)

- x в степени y

Списковые

len(A)

- длина списка A

min(A), max(A)

- минимальный и максимальный элемент списка A

Методы объекта "список". Т.к. список - объект, у него есть свои методы. Они могут оказаться полезными при работе.

append(x)

- добавление элемента со значением x в конец списка

extend(L)

- добавление в конец списка всех элементов списка L

insert(i, x)

- вставка элемента со значением x перед i-м элементом. Именно вставка, т.к. индексы всех элементов с номерами k≥i в результате вставки увеличиваются на 1

remove(x)

- удаление из списка первого элемента со значением x. Если такого элемента нет - ошибка

pop({i})

- удаление из списка элемента с заданным индексом и возвращение его значения. Если индекс не указан - работает последний элемент списка

index(x)

- возвращение индекса первого элемента списка со значением x. Если такого элемента нет - ошибка

count(x)

- возвращение количества повторений значения x среди элементов списка

sort()

- сортировка элементов списка. Отсортированный список помещается на место исходного

reverse()

- изменение порядка следования элементов списка на обратный

A = [1,2,4]
A.append(5) # A = [1,2,4,5]
A.extend([25,3,10]) # A = [1,2,4,5,25,3,10]
A.insert(2,3) # A = [1,2,3,4,5,25,3,10]
A.remove(4) # A = [1,2,3,5,25,3,10]
x = A.pop() # x = 10, A = [1,2,3,5,25,3]
i = A.index(5) # i = 3
c = A.count(3) # c = 2
A.sort() # A = [1,2,3,3,5,25]

Модули math и cmath. В Питоне есть множество стандартных модулей, содержащих полезные функции на все случаи жизни. Например, модуль math - содержит математические функции для действительных чисел, а cmath - для комплексных.
Подключение модуля к программе осуществляется очень просто - с помощью предложения import имя_модуля. Для доступа к функциям или переменным модуля необходимо использовать приставку "имя_модуля." перед именем: math.pi, math.cos(1).

Рассмотрим состав модулей math и cmath. В них обоих определены следующие константы:

pi

- число "пи"

e

- основание натурального логарифма

acos(z)

- арккосинус

asin(z)

- арксинус

atan(z)

- арктангенс

cos(z)

- косинус

cosh(z)

- гиперболический косинус

exp(z)

- экспонента

log(z)

- натуральный логарифм

log10(z)

- логарифм по основанию 10

sin(z)

- синус

sinh(z)

- гиперболический синус

sqrt(z)

- квадратный корень

tan(z)

- тангенс

tanh(z)

- гиперболический тангенс

atan2(y, x)

- возвращает atan(y/x)

ceil(x)

- наименьшее целое число, превышающее x

fabs(x)

- модуль

floor(x)

- наибольшее целое число, не превышающее x

pow(x, y)

- возведение x в степень y

acosh(x)

- ареа-косинус

asinh(x)

- ареа-синус

atanh(x)

- ареа-тангенс

import math
print math.cos(math.pi) # vivod "-1"
x = 1
print math.cos(x)**2+math.sin(x)**2 # vivod "1"
print math.asin(1) # vivod "pi/2"

import cmath
z = 2+3j
print cmath.log(cmath.sinh(z)+cmath.cosh(z)) # vivod 2+3j, t.k. chx+shx=exp(x)
print cmath.sqrt(z)**2 # vivod 2+3j

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

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

Александр Рябов. Июль 2004, Украина.
ryabov@ua.fm