Введение в язык Питон.

Питон – это объектно-ориентированный, интерпретируемый, переносимый язык сверхвысокого уровня. Программирование на Питоне позволяет получать быстро и качественно необходимые программные модули. Интерпретатор Питона может быть перенесён на любую платформу, будь то Unix, Windows, Linux, RiscOS, MAC, Sun. При написании кода на Питоне вы не должны заботиться о конечной платформе, кроме тех случаев, когда вы используете специфические модули для данной системы. Таким образом, Питон представляет серьёзную угрозу для Java, обеспечивая лёгкую переносимость, одновременно сочитая в себе средства доступа к ресурсам операционной системы. В отличие от Java Питон не столь строг к использованию объектов, но реализуются они столь просто, что любой программист легко понимает сущность объектно-ориентированного подхода. Кроме этого, модули Питона могут быть с лёгкостью использованы в ваших программах на С++ и, если вы знаете этот язык программирования, то освоение Питона будет для вас тривиально. Питон идеален в качестве cgi скриптов для веб-страниц, так как использует быстрый, эффективный и мощный интерпретатор. Питон может служить как в качестве языка для обучения, так и в качестве языка для разработки больших систем. Он прост, мощен и его очень легко освоить. Программы на Питоне можно написать в два раза быстрее, чем на Си, используя структуры высокого уровня, но по мощности он приближается к С++, избегая недостатков его безопасности и средств, черезмерно усложняющих язык(указатели).

Модули для Питона можно найти в сети Питона(http://www.python.org). Модули Питона, как и сам интерпретатор свободны и доступны в виде исходных кодов или двоичных пакетах. В данном руководстве я постараюсь осветить основные аспекты Питона, как языка программирования, углублённое и полное руководство по языку может быть найдено на сайте http://www.python.org (на английском языке). В данном руководстве я использовал версию Питона для О.С. Linux, пользователи других систем могут найти особенности своих систем на сайте www.python.org

Запуск интерпретатора обычно осуществляется прямой командой python, или с указанием полного пути к интерпретатору. Для того, чтобы выйти из Питона, воспользуйтесь комбинацией клавиш CTRL+D – Unix; CTRL+Z – Dos + Windows; если это не помогло набе­рите в ответ на приглашение интерпретатора(>>>) import sys; sys.exit(). Интерпретатор работает в двух режимах: интерактивном и собственно интерпретатора. Вход в интерактивный режим осуществляется вводом python без параметров, параметр file вызывает интерпретацию указанного файла. Для системы типа Unix есть альтернатива написания скриптов на Питоне – просто введите

#!/usr/local/bin/python
#Some python script

Итак, вначале рассмотрим интерактивный режим: он напоминает shell. Вначале Питон пишет информацию о себе и о системе, а затем выводит своё приглашение(>>>), с этого момента он будет интерпретировать всё, поступающее с клавиатуры. Заставить Питон интерпретировать введённую вами строку можно клавишей Enter. Комментарии в Питоне обозначаются предваряющим их символом # и продолжаются до конца строки(т.е в Питоне все комментарии являются однострочными), при этом не допускается использование пред символом # кавычек:

>>> a = “Это строка”#Это комментарий
>>> b = “#Это уже НЕ комментарий”

Интерпретатор Питона очень прост в использовании, например, вы можете его использовать в качестве калькулятора:

>>> 2+2
4
>>>
# Это комментарий
... 2+2
4
>>> 2+2  # и комментарий в одной строке с оператором
4
>>> (50-5*6)/4
5
>>> #Целочисленное деление использует ОКРУГЛЕНИЕ до ближайшего меньшего целого
... 7/3
2
>>> 7/-3
-3

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

>>> width = 20
>>> height = 5*9
>>> width * height
900

>>>some_string = “Это очень хорошая строка”

>>>some_string 

Это очень хорошая строка

>>>width = some_string

ERROR: не могу присвоить переменные разных типов

Вы также можете присваивать одно и то же значение нескольким переменным одновременно:

>>> x = y = z = 0  # Присвоим нуль переменным x,y,z
>>> x
0
>>> y
0
>>> z
0

Питон полностью поддерживает операции чисел с точкой:

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2 #Обратите внимание, число с точкой делим на целое и получаем результат с точкой
3.5

В Питоне предусмотрена встроенная поддержка комплексных чисел. Воображаемая часть числа имеет суффикс j или J(1j; 5J), комплексные числа, имеющие ненулевую действительную часть обозначаются как real+imaginj или используя функцию complex(real, imagin):

>>> 1j * 1J
(-1+0j)
>>> 1j * complex(0,1)
(-1+0j)
>>> 3+1j*3
(3+3j)
>>> (3+1j)*3
(9+3j)
>>> (1+2j)/(1+1j)
(1.5+0.5j)

Части комплексных чисел представляются, как числа с точкой, чтобы разделить комплексное число z на части, воспользуйтесь конструкцией z.real и z.imag:

>>> a=1.5+0.5j
>>> a.real
1.5
>>> a.imag
0.5

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

float() - приведение к числу с точкой

int() - приведение к целому числу

long() - приведение к длинному целому числу

Внимание: эти функции не работают для комплексных чисел, для них используйте разбиение на части или вычисление длины вектора функцией abs(z):

>>> a=3.0+4.0j
>>> float(a)
ERROR: не могу привести тип complex к типу float
>>> a.real
3.0
>>> a.imag
4.0
>>> abs(a)  # sqrt(a.real**2 + a.imag**2)
5.0

В интерактивном режиме последнее выведенное на экран выражение сохраняется в переменной по умолчанию _. Это удобно для продолжения вычислений в выражениях:

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

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

Строки:

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

>>> 'привет, Питон'
'привет, Питон'
>>> 'привет, \”Питон\”'
'привет, “Питон”'
>>> "doesn't"
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.' 

В английском одинарные о двойные кавычки употребляются в разном контексте

Если строка слишком длинная, то можно уместить её в нескольких строках путём указания в конце символа \, например:

а = “Это очень длинная \
        строка, содержащая \
        3 строчки\n”
>>>print a

Это очень длинная строка, содержащая 3 строчки

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

Можно также окружать строки тройными кавычками в операторе print(вывести строку в stdout), например:

print """
Usage: thingy [OPTIONS] 
     -h                        Display this usage message
     -H hostname               Hostname to connect to
"""
выведет следующее: 

Usage: thingy [OPTIONS]
     -h                        Display this usage message

    -H hostname Hostname to connect to

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

Со строками можно производить некоторые простые операции, такие как склеивание(+) и повторение строк(*):

>>> word = 'Да' + 'Нет'
>>> word
'ДаНет'
>>> '<' + word*5 + '>'
'< ДаНетДаНетДаНетДаНетДаНет >'

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

>>> word[4]
'Е'
>>> word[0:2]
'Да'
>>> word[2:4]
'Не'

Внимание: в Питоне нельзя непосредственно изменять символы в строке через индексы – это вызовет ошибку интерпретатора. Можно только читать значение символа, что позволяет бы­стро создавать новые строки по частям других:

>>> 'x' + word[1:]#Все символы начиная со 2-го
'хаНет'
>>> 'Не' + word[4]#Только пятый символ
'Нее'

Все индексы начинают отсчёт с начала строки, однако применение отрицательных индексов позволяет вести отсчёт с конца строки:

>>> word[-1]  #Последний символ
'т'
>>> word[-2]     #Предпоследний символ
'е'
>>> word[-2:]    # Два последних символа
'ет`
>>> word[:-2]    #Все, кроме 2-х последних символов
'ДаН' 

Представим, как работают индексы:

Если вы задаёте индексы, будте внимательны к этим важным деталям. Кроме того, если вы напишете word[:-100], то индекс будет урезан до -5(то есть выведена вся строка), но если вы укажите несуществующий элемент в качестве индекса 1-го символа word[-100], то будет выдана ошибка.

Полезный совет: функция len(строка) возвращает длину переданной строки

>>>len(word)
5

Строки юникода.

Строки Юникода www.unicode.org позволяют поддерживать символы всех алфавитов, древних и ныне существующих. Дело в том, что обычные строки могут содержать до 256 различных символов, это очень ограничивало алфавит компьютера. Со введением юникода в строке может содержаться до 65536(!) различных символов. Питон, как язык, поддерживающий всё новое в компьютерном мире, поддерживает юникод. Строки юникода обозначаются символом u перед открывающей кавычкой., например u”РоссияUSA”. В юникоде также имеются управляющие символы, но обозначаются они по-другому в формате \0000, где 0000 некий управляющий символ(например \0020 – пробел). Полный список управляющих символов юникода можно найти на сайте www.unicode.org . Если вы не хотите отображение управляющих символов, поставьте перед открывающей кавычкой символы ur. Все операции со строками обычного формата применимы к строкам юникода. То есть внутри Питона юникод и обычный текст во многом схожи, и вы можете использовать и то и другое представление строк(учтите, однако, что текст в 2 раза компактнее юникода, зато юникод способен воспринимать любой алфавит). Поэтому, что вам нужно употреблять, зависит от конкретной задачи(переносимость или компактность).

Все строки юникода имеют метод закодировать encode(), используемый для представления символов юникода в качестве управляющих:

>>> u"дць".encode('utf-8')
'\xc3\xa4\xc3\xb6\xc3\xbc'

Utf-8 означает тип кодировки юникода(Utf-8, Utf-16, ASCII).

Функция unicode() обеспечивает доступ ко всем кодерам / декодерам юникода: Utf-8, Utf-16, Latin-1, ASCII(0...127 символов), KOI-8, cp1251, cp866. Кодер / декодер по умолчанию – это ASCII, все вызовы функций str() и print используют кодер по умолчанию.

>>> unicode('\xc3\xa4\xc3\xb6\xc3\xbc',
'utf-8')
u'\xe4\xf6\xfc'

Внимание:кодер по умолчанию ASCII не поддерживает кириллицу, поэтому в функции unicode надо указать предпочтительную кодировку(например, KOI-8).

>>> u"abc"
u'abc'
>>> str(u"abc")
'abc'
>>> u"дць"
u'\xe4\xf6\xfc'
>>> str(u"дць")
ERROR: символ с кодом больше 127, не входит в ASCII.

Введение в списки.

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

>>> a = ['Да', 'Нет', 100, 1234] #Список состоит из разных типов
>>> a
['Да', 'Нет', 100, 1234]

К отдельным элементам списка можно обращаться по индексу, аналогично индексам в строках:

>>> a[0]
'Да'
>>> a[3]
1234
>>> a[-2]
100
>>> a[1:-1]
['Нет', 100]
>>> a[:2] + ['Ой', 2*2]
['Да', 'Нет', 'Ой', 4]
>>> 3*a[:3] + ['Ай!']
['Да', 'Нет', 100, 'Да', 'Нет', 100, 'Да', 'Нет', 100, 'Ай!']

В отличие от строк в Питоне вы можете изменять отдельные элементы списка по индексу(при этом учтите: чтобы удалить элемент из списка надо присвоить ему пустой список[]):

>>> a
['Да', 'Нет', 100, 1234]
>>> a[2] = a[2] + 23#Увеличиваем 100 на 23
>>> a
['Да', 'Нет', 123, 1234]

Возможно также присваивание частей списков частям другого списка ил целому списку. Возможно склеивание частей списков:

>>> # Заменим некоторые элементы
... a[0:2] = [1, 12]
>>> a
[1, 12, 123, 1234]
>>> # Удалим некоторые элементы
... a[0:2] = []
>>> a
[123, 1234]
>>> # Теперь вставим
... a[1:1] = ['ёпрст', 'абвгд']
>>> a
[123, 'ёпрст', 'абвгд', 1234]
>>> a[:0] = a     # Вставим копию самого списка в начало списка
>>> a
[123, 'ёпрст', 'абвгд', 1234, 123, 'ёпрст', 'абвгд', 1234]

Функция len() позволяет определить длину списка(т.е. количество элементов в нём):

>>> len(a)
8

Возможно создание вложенных списков, т.е. списков, содержащих в качестве элементов другие списки:

>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2
>>> p[1].append('вставление')     # См далее(вставляет элемент в конец списка) 
>>> p
[1, [2, 3, 'вставление'], 4]
>>> q
[2, 3, 'вставление']

Внимание: p[1] и q ссылаются на один и тот же объект(к этому я вернусь далее).

Основные элементы программирования.

Если вы читали всё, что я написал до этого пункта, то можете подумать, что Питон – это очень убогий язык. Но в действительности это не так. Вы можете писать на Питон программы любой сложности. Например, нам надо найти первые числа Фиббоначи(числа Фиббоначи характеризуются тем, что каждое следующее число Фибоначчи равно сумме двух предыдущих):

>>> # Числа Фибоначчи:
... # Сумма двух предыдущих определяет следующее
... a, b = 0, 1#Два первых числа
>>> while b < 10:#Цикл ниже выполняется пока число Фибоначчи меньше 10
...       print b
...       a, b = b, a+b
... 

Результат выполнения программы:

1
1
2
3
5
8

Эта программа демонстрирует многие возможности Питона.

• Первая строка демонстрирует присваивание двум переменным двух различных значений

• Вторая строка демонстрирует заголовок цикла while(пока). Этот цикл (после двоеточия) обозначается отступом и выполняется пока условие в заголовке цикла(b < 10) является верным(или не равно нулю, например цикл while 0 выполняться не будет, а цикл while 1 будет выполняться бесконечно и зациклит программу, если внутри цикла не предусмотрено какое-либо условие выхода(плохой стиль программирования)). Попробуйте изменять число в цикле, и вы увидите, как будет изменяться верхнее значение переменной b. Кроме этого, в цикле while могут использоваться строки, списки, при этом всё, имеющее нулевую длину, считается нулём, а всё, имеющее ненулевую длину, считается истиной. В операторе while вы можете использовать следующие операции: < (меньше), > (больше), ==(равно), <= (меньше или равно), >= (больше или равно) и != (не равно).

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

• Четвёртая строка также демонстрирует присваивание двум переменным двух значений. Самое важное – отметить, что вначале оцениваются выражения справа(т.е b, a + b), а затем эти выражения подставляются в левую часть.

  Кроме этого, отметим, что логические части программы(такие как, например, тело цикла) отмечаются отступами от основного уровня текста программы, а не специальными символами({} в Си и begin end в Паскале). Заметьте также, что после заголовка следует символ двоеточия.

Приведём ещё некоторые примеры несложных программ:

>>> i = 256*256
>>> print 'Значение i`, i
Значение i 65536

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

>>> a, b = 0, 1
>>> while b < 1000:
...     print b,
...     a, b = b, a+b
... 
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

Заметьте, что перевод строки осуществляется интерпретатором автоматически, когда следующая переменная не умещается в текущей строке.