Версия для печати

Питон на русском

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

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

Скрипты CGI на Питоне.

Введение в CGI.

CGI означает Common Gateway Interface и является мощным средством динамической генерации Веб страниц. CGI скрипты вызываются веб-сервером, а результат их работы отправляется на клиентский броузер. Таким образом, CGI скрипты способны выполнять любые запросы клиента на сервере и отправлять клиенту результаты запроса.

Для написания CGI скриптов пригоден любой интерпретируемый или компилируемый язык программирования, в том числе и Питон. Типичная CGI программа состоит из двух частей: из передачи HTTP заголовков и передачи HTML данных. Веб-сервер связывает вывод CGI скрипта со вводом у броузера. Всё, что выводится CGI скриптом передаётся на клиентскую машину. Обратная связь осуществляется передачей данных от сервера клиенту путём передачи параметров.

Вот пример типичной CGI программы:

вначале выводятся заголовки

print "Content-Type: text/html" # Определение типа HTML

print # Пустая строка означает окончание передачи заголовков

теперь выводим основной текст в формате HTML

print "<TITLE>CGI script output</TITLE>"

print "<H1>This is my first CGI script</H1>"

print "Hello, world!"

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

Итак передача параметров в CGI скрипт осуществляется двумя методами: прямой передачей параметров в имени URL в формате “http://адрес_скрипта?имя_параметра1=значение_параметра1&имя_параметра2=значение2...”

при этом способе в программе становятся доступными переменные имя_параметра и им присваиваются переданные значения; второй способ состоит в передаче параметров через HTML форму. Во втором случае необходимо применение модуля CGI:

import cgi

Затем, чтобы включить обработку ошибок полезно вставить в начало следующие строчки:

import cgitb; cgitb.enable()

Если же Вы не хотите, чтобы ошибки Вашего скрипта передавались в броузер клиента, а передавались в log файл, то сделайте следующее:

import cgitb; cgitb.enable(display=0, logdir="/tmp")

Итак, во-первых разберёмся с формами. В модуле CGI есть полезный класс: FieldStorage, который содержит в себе переданную в форме информацию. По сути дела этот класс представляет из себя словарь, обладающий теми же свойствами, что и обычный питоновский словарь, например методами has_key и key(), также можно определить его длину функцией len(). По умолчанию FieldStorage не содержит тех значений, которые в форме остались пустыми (например пустое поле ввода). Чтобы FieldStorage включал все переменные формы сделайте так:

form = cgi.FieldStorage(keep_blank_values=true)

Покажем пример работы с формой:

#Передали заголовки ранее

form = cgi.FieldStorage() #Здесь пустых значений нет!

if not (form.has_key("name") and form.has_key("addr")): #А есть ли такие поля?

print "<H1>Error</H1>" #Плохая форма

print "Please fill in the name and addr fields."

return

print "<p>name:", form["name"].value

print "<p>addr:", form["addr"].value #Дальше обрабатываем форму

Учтите, если в форме присутствует несколько элементов с одним именем, то form.getvalue() вернёт список значений всех элементов с этим именем. Для того чтобы понять, элемент это или список удобно использовать функцию type. Как обычно, приведу пример:

from types import ListType

value = form.getvalue("username", "")

if isinstance(value, ListType):

# Это список

usernames = ",".join(value)

else:

# Или это просто переменная или полная лажа ;-)

usernames = value

Ну что ещё можно сказать? Хотел бы отметить использование File Upload если в форме есть переменная, представляющая собой файл, то при вызове form.getvalue() этот файл будет загружен из сети в память. Переменная же представляет собой обычный файл и его можно читать, используя методы модуля file:

fileitem = form["userfile"]

if fileitem.file:

# Это и вправду файл!

linecount = 0

while 1:

line = fileitem.file.readline()

if not line: break

linecount = linecount + 1

Далее будут рассмотрены все методы модуля cgi, а пока ограничимся этим :-(

One Day of IDLE Toying

• (German version translated by Gregor Lingl)
• (Portuguese version translated by Fernando Manaзas Ferreira)

This page is meant to help new users of Python who might feel a little disoriented. One question that might come to mind is: ok, we've installed Python... ummm... now what?

It might be nice to have a "visual" guide to reduce any initial anxieties. That's what this page is for. The plan is to go through a small session with IDLE: the Integrated Development Environment. IDLE is designed to provide a simple way of exploring the language. During this session, I'll make a few fumbling mistakes, just to show what to expect when things don't go exactly hunky-dory.

By the way, this is an online document If you have any suggestions, or if you want to make corrections or improvements, please feel free to email at dyoo@hkn.eecs.berkeley.edu. Small plug: also, don't forget that there's a great resource in the Python Tutor mailing list: we're a group of people who like to show each other interesting stuff in Python. We're all learning together, so feel free to subscribe and join us.

Changes

• January 30, 2002: Fernando Manaзas Ferreira sent me a Portuguese translation. This is wonderful!
• December 4 (Evening): Gregor Lingl sent me a German translation of the guide. Thank you!
• December 4, 2001: there's enough demand for this page to be done, so I've tried to patch the FIXME's throughout this page.]
• [June 19, 2001: my computer monitor has just burnt to a brown crisp, so image updates to this page will be a little delayed until I get it replaced. My apologies!]

Перевод был выполнен Стаховым Всеволодом CEBKA@smtp.ru. Оригинальный документ лежит здесь.

Предположим, что Питон у Вас уже установлен, если нет - то сходите на http://python.org и скачайте свежую версию интерпретатора. Когда писалась эта статья, то свежей была версия 2.1. Первой вещью, которую вы сделаете, будет запуск интегрированной среды Питона IDLE! Мы сделаем это, запустив соответствующую ссылку из меню Start в только что созданной программной группе Питона.

О чудо! оно работает:

Это главное окно IDLE и то, что мы видим сейчас, называется окном интерпретатора. Интерпретатор позволяет Вам работать с Питоном в интерактивном режиме, т.е. Вы вводите команды, а Питон их выполняет после нажатия клавиши Enter и выводит результат. Мы будем в дальнейшем активно использовать окно интерпретатора, так как можно видеть результат немедленно. Можно просто представить его как очень навороченный калькулятор.

Пришло время что-нибудь сотворить! По негласной традиции заставим Питона произнести легендарное "Hello World".

Эти '>>>' играют роль приглашения для нас: Питон готов выполнять наши команды. Также заметим, что Питон выводит результат немедленно после нажатия клавиши Enter.

На первый взгляд просто, не так ли. Попробуем применить другие команды. Если мы посмотрим ниже:

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

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

Теперь, достаточно поэксперементировав, вы наверняка задаётесь вопросом - как сохранить плоды своих трудов, чтобы потом как-либо их использовать?

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

Давайте так и сделаем. Вначале создайте новое окно.

Вот так:

Заметьте, окно совершенно пустое. Это значит, что оно только для наших команд: Питон не будет интерпретировать эти команды сразу, а сделает это, когда мы этого захотим. Такое окно мы будем называть програмным окном.

Теперь введём текст, который мы хотим сохранить. Для этого можно скопировать тект, набранный ранее, и вставить его в програмное окно.

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

Давайте теперь сохраним файл:

Теперь, когда файл сохранён, как нам его запустить? Если мы посмотрим меню,

то увидим пункт Run Script, это то, что нам нужно. Мы хотим, чтобы файл был интерпретирован Питоном, а результат его выполнения был отображён в интерактивном окне.

Кстати, я сделал очепятку: "забыл" поставить закрывающую кавычку во второй строчке. Скажется ли это на результате?

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

Питон часто помогает в обнаружении ошибки, так как он точно указывает место ошибки и её тип. В данном случае это просто отсутствие закрывающей кавычки. Давайте добавим её и всё.

Допустим, мы исправили эту дурацкую очепятку. Давайте снова запустим программу!

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

Ну теперь мы сохранили наше творение, пора его запустить(надеюсь, оно заработает ;)

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

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

В меню Файл есть команда открыть:

Если всё хорошо, то мы увидим програмное окно с сохранённой программой:

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

Вы узнали об основах пользования IDLE и это позволит Вам писать в дальнейшем всё, что угодно на Питоне. Но мы не рассмотрели множество других возможностей IDLE. Но это слишком много для данного руководства. Вы можете узнать об этих возможностях, эксперементируя, а можете сходить на страницу IDLE Documentation" page с полным описанием данной среды. Можете также подписаться на рассылки Python Tutor. Удачи Вам в освоении Питона!

Назад

Основы программирования.

Основные операторы.

1. Оператор if.

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

   >>> x = int(raw_input("Введите целое число: "))

   >>> if x < 0:

   ... x = 0

   ... print 'Отрицательное число стало нулём'

   ... elif x == 0:

   ... print 'Это число - нуль'

   ... elif x == 1:

   ... print 'Это число - 1'

   ... else:

   ... print `Это число больше единицы'

   ...

   Далее могут быть ещё операторы elif(аналог case в Си). Оператору if, как видно, сопутствуют операторы else(“иначе” - блок кода выполняется если условие в заголовке if приняло нулевое значение, т.е стало ложным) и elif(“иначе если” - блок кода выполняется если условие в заголовке if приняло нулевое значение, т.е стало ложным, а значение в заголовке данного оператора стало ненулевым, т.е истинным).

2. Оператор for.

   Оператор for несколько необычен в Питоне, он имеет вид for некая_переменная in некий_диапазон. Блок кода после заголовка выполняется, пока некая_переменная принадлежит некому_диапазону(причём этот диапазон может быть списком, числовой последовательностью, массивом каких-либо значений):

   >>> # Определим какие-то строки:

   ... a = ['Linux', 'Open', 'Office']

   >>> for x in a:

   ... print x, len(x)

   Результат работы:

   Linux 5

   Open 4

   Office 6

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

   >>> for x in a[:]: # здесь мы делаем копию всего списка a в переменной x

   ... if len(x) > 6: a.insert(0, x)#Если длина строки списка больше 6

   ...

   >>> a

   Результат работы:

   [Linux , Open, Office, Office]

   Для задания диапазона в форме арифметической прогрессии (1 2 3 4 5 6...) удобно пользоваться функцией range(). Она имеет три формы, рассмотрим на примерах все:

   >>> range(10)

   [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

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

   >>> range(5, 10)

   [5, 6, 7, 8, 9]

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

   >>> range(0, 10, 3)

   [0, 3, 6, 9]

   >>> range(-10, -100, -30)

   [-10, -40, -70]

   Эта форма возвращает все целые значения в диапазоне от начального до конечного с шагом, заданным третьим параметром. Причём, если, например, вы попробуете ввести range(1, 100, -1), то очевидно, что чисел в этом диапазоне нет, то есть результатом будет пустое множество([]).

   Если вы хотите задать диапазон через количество элементов в списке, то следует воспользоваться функцией range в сочетании с функцией len:

   >>> a = [`Linux', 'is', 'the', 'best', 'system']

   >>> for i in range(len(a)):

   ... print i, a[i]#Обращение к элементу списка по его индексу

   ...

   0 Linux

   1 is

   2 the

   3 best

   4 system

3. Прерывание и продолжение циклов for и while.

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

   >>> for n in range(2, 10):#Задаёт верхнюю границу

   ... for x in range(2, n):

   ... if n % x == 0:#Если n делится на x без остатка и n не простое число

   ... print n, 'равно', x, '*', n/x

   ... break#Выход из цикла по x, следующее n

   ... else:

   ... # если n не разделилось без остатка ни на одно x от 2 до n, то

   ... print n, 'простое число'

   ...

   Результат работы:

   2 простое число

   3 простое число

   4 равно 2 * 2

   5 простое число

   6 равно 2 * 3

   7 простое число

   8 равно 2 * 4

   9 равно 3 * 3

4. Оператор pass.

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

   >>> while 1:

   ... pass # Бесконечный цикл, ничего не делающий: ждём прерывания с клавиатуры

   ...

   Функции.

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

>>> def fib(n): # Функция, выводящая на экран числа Фибоначчи, не превосходящие n

... """Числа Фибоначчи"""

... a, b = 0, 1

... while b < n:

... print b,

... a, b = b, a+b

...

>>> # Теперь функцию можно вызвать

... fib(2000)

Числа Фибоначчи

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

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

>>> def fib(n): # Функция, возвращающая числа Фибоначчи, не превосходящие n

... result = [1]#Этот список будет содержать числа Фибоначчи

... a, b = 0, 1

... while b < n:

... print b,

... a, b = b, a+b

... result.append(b);#Вставление в результативный список очередного числа

... return result #Возвращение результата

...

>>> # Теперь функцию можно вызвать

... fib(2000)

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

[1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597]

В определении функций есть некоторые нюансы. Рассмотрим, к примеру, функцию range(). Её можно вызвать в 3-х разных формах – с один параметром, с двумя и с тремя. Для организации такого поведения совсем необязательно описывать три различные функции, можно применить параметры по умолчанию:

def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):

while 1:

ok = raw_input(prompt)

if ok in ('д', 'да', 'yes'): return 1

if ok in ('н', 'нет', 'no', 'nop'): return 0

retries = retries - 1

if retries < 0: raise IOError, 'refusenik user'

print complaint

или в таком виде:

i = 5

def f(arg=i):

print arg

i = 6

f()#Выведет не 6, а 5

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

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

def f(a, L=[]):

L.append(a)

return L

print f(1)

print f(2)

print f(3)

Результат работы программы:

[1]

[1, 2]

[1, 2, 3]

Если вам нужно, чтобы параметры по умолчанию передавались раздельно, то используйте следующую форму:

def f(a, L=None):

if L is None:

L = []

L.append(a)

return L

Ключи.

В Питоне есть другая возможность передавать значения в функцию – через ключи в формате 'ключ=значение', например:

def parrot(voltage, state='крутой', action='шок', type='Волнистый'):

print "-- "Попугай не будет", action,

print "если вы пропустите ток в", voltage, "вольт через него."

print "-- Попугай", type

print "-- Это", state, "!"

Такую функцию можно вызвать любым из способов ниже:

parrot(1000)

parrot(action = 'А-а-а-а-а-у-у-ш-ш-ш', voltage = 1000000)

parrot('тысячу', state = 'заболеет')

parrot('миллион', 'вернётся к жизни', 'прыжок')

А вот таким образом функцию вызывать нельзя:

parrot() # требуемый аргумент опущен

parrot(voltage=5.0, 'dead') #аргумент не ключ использован как ключ

parrot(110, voltage=220) # повторение значение одного и того же аргумента

parrot(actor='John Cleese') # неизвестный ключ

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

>>> def function(a):

... pass

...

>>> function(0, a=0)

ERROR: ключ переопределён

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

def cheeseshop(kind, *arguments, **keywords):

print "-- У вас есть какие-нибудь", kind, '?'

print "-- Нет, всех съели"

for arg in arguments: print arg

print '-'*40

for kw in keywords.keys(): print kw, ':', keywords[kw]

Функция может быть вызвана, например, так:

cheeseshop('Зонты', "Очень жаль.",

"Действительно ужасно жаль, товарищ.",

client='Михаил Горбачёв',

shopkeeper='Борис Ельцин',

sketch='Белый Дом')

и вот каким будет результат работы:

-- У вас есть какие-нибудь зонты?

-- Нет, всех съели

Очень жаль.

Действительно, ужасно жаль.

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

client : Михаил Горбачёв

shopkeeper : Борис Ельцин

sketch : Белый Дом

Передача в функцию переменного числа аргументов.

Часто используемым приёмом в программировании является передача в функцию переменного числа аргументов. Для этого в Питоне можно воспользоваться символом * перед списком аргументов переменной длины. Аргументы в теле функции могут быть разделены(см. выше). Перед списком аргументов может следовать(необязательно) один или несколько обязательных аргументов:

def fprintf(file, format, *args):

file.write(format % args)

Использование лямбда функций.

Лямбда функции пришли в Питон из языка Лисп и могут показаться необычными программисту на Си. Лямбда функции – это небольшие функции, которые создают другие функции, на своей основе. Чтобы быть более понятным, приведу такой пример: lambda a, b: a+b – вычисляет сумму двух своих аргументов. На основе функции, возвращающей lambda можно построить другие функции, например:

>>> def make_incrementor(n):

... return lambda x: x + n#x – параметр, который передаётся в порождённую функцию f(x)

...

>>> f = make_incrementor(42)

>>> f(0)

42

>>> f(1)

43

Документирование функций.

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

n=10
5 ?
>
7
<
6
Yes
Yahoo. I`m winner. Thank you!

n=10 --> n = 5
5?
> --> n=7
< --> n=6...

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

Списки.

Списки широко распространены в Питоне и имеют множество методов манипулирования(метод отделяется от имени списка точкой: имя_списка.метод()):

• append(x) вставляет в конец списка элемент х. Эквивалентно a[len(a):] = [x].

• extend(L) добавляет списку в конец все элементы списка L. Эквивалентно a[len(a):] = L.

• insert(i, x) вставляет элемент x в позицию перед индексом i в списке(для вставки элемента в начало списка воспользуйтесь insert(0, x)).

• remove(x) удаляет первое вхождение x в список, вызывает ошибку если элемент x не найден.

• pop(i) удаляет элемент с индексом i и возвращает его. Если вызвать pop() без параметров, то будет возвращён и удалён последний элемент списка.

• index(x) возвращает индекс первого вхождения элемента х в список, вызывает ошибку если элемент x не найден.

• count(x) возвращает количество вхождений элемента x в список.

• sort() сортирует элементы списка по возрастанию.

• reverse() переворачивает список в обратном порядке.

  Примеры использования методов списков:

>>> a = [66.6, 333, 333, 1, 1234.5]

>>> print a.count(333), a.count(66.6), a.count('x')

2 1 0

>>> a.insert(2, -1)

>>> a.append(333)

>>> a

[66.6, 333, -1, 333, 1, 1234.5, 333]

>>> a.index(333)

1

>>> a.remove(333)

>>> a

[66.6, -1, 333, 1, 1234.5, 333]

>>> a.reverse()

>>> a

[333, 1234.5, 1, 333, -1, 66.6]

>>> a.sort()

>>> a

[-1, 1, 66.6, 333, 333, 1234.5]

Использование списков, как стеков.

Стек – это структура данных, организованнная по принципу “Последним пришёл, первым ушёл”(LIFO). В Питоне нет встроенного класса стека, но вы можете использовать списки Питона так, как они были бы стеками: для добавления элемента используйте append, а для получения последнего – метод pop() без аргумента(метод pop удаляет элемент). Например:

>>> stack = [3, 4, 5]

>>> stack.append(6)

>>> stack.append(7)

>>> stack

[3, 4, 5, 6, 7]

>>> stack.pop()

7

>>> stack

[3, 4, 5, 6]

>>> stack.pop()

6

>>> stack.pop()

5

>>> stack

[3, 4]

Использование списков, как очередей.

Очередь – это другая структура данных, организованнная по принципу “Первым пришёл, первым ушёл”(FIFO). В Питоне нет встроенного класса очереди, но вы можете также использовать списки Питона: для добавления элемента используйте append, а для получения последнего – метод pop(0)(метод pop удаляет элемент). Например:

>>> queue = [1, 2, 3]

>>> queue.append(4) # Terry arrives

>>> queue.append(5) # Graham arrives

>>> queue.pop(0)

5

>>> queue.pop(0)

4

>>> queue

[1, 2, 3]

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

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

filter()

map()

reduce()

Функция filter() может использоваться для выборки значений из списка, условием служит функция пользователя. Синтаксис функции filter(имя_функции, список). Функция возвращает только те элементы списка, для которых значение функции принимает ненулевое(истинное) значение:

>>> def f(x): return x % 2 != 0 and x % 3 != 0#Выбор некоторых простых чисел

...

>>> filter(f, range(2, 25))

[5, 7, 11, 13, 17, 19, 23]

Функция map() имеет следующий синтаксис: map(имя_функции, список). Map() возвращает список, являющийся результатом работы функции для каждого элемента списка:

>>> def cube(x): return x*x*x#Куб числа

...

>>> map(cube, range(1, 11))

[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

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

>>> seq = range(8)

>>> def square(x): return x*x#Квадрат числа

...

>>> map(None, seq, map(square, seq))

[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49)]

Функция reduce() имеет следующий синтаксис: reduce(имя_функции, список). Она возвращает единственное значение, являющееся выполнением пользовательской функции над первыми двумя элементами списка, затем с результатом выполнения функции и следующим элементом списка, например прогармма считает сумму всех чисел от 1 до 10:

>>> def add(x,y): return x+y

...

>>> reduce(add, range(1, 11))

55

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

Выражения в списках.

В Питоне есть альтернативный способ создания списков по определённым правилам, позволяющий избегать использования функций filter(), map(), reduce(): использование выражений внутри списков. Такие выражения имеют следующий формат: заголовок цикла for, задающий ограничения при создании списков, за этим циклом может(необязательно) следовать некоторое количество условий if и циклов for, по которым, собственно, и создаётся результативный список. Приведём пример таких выражений:

>>> freshfruit = [' банан', ' ананас', 'яблоко ']

>>> [weapon.strip() for weapon in freshfruit]

['банан', 'ананас', 'яблоко']

>>> vec = [2, 4, 6]

>>> [3*x for x in vec]

[6, 12, 18]

>>> [3*x for x in vec if x > 3]

[12, 18]

>>> [3*x for x in vec if x < 2]

[]

>>> [{x: x**2} for x in vec]

[{2: 4}, {4: 16}, {6: 36}]

>>> [[x,x**2] for x in vec]

[[2, 4], [4, 16], [6, 36]]

>>> [(x, x**2) for x in vec]

[(2, 4), (4, 16), (6, 36)]

>>> vec1 = [2, 4, 6]

>>> vec2 = [4, 3, -9]

>>> [x*y for x in vec1 for y in vec2]

[8, 6, -18, 16, 12, -36, 24, 18, -54]

>>> [x+y for x in vec1 for y in vec2]

[6, 5, -7, 8, 7, -5, 10, 9, -3]

>>> [vec1[i]*vec2[i] for i in range(len(vec1))]

[8, 12, -54]

Оператор del.

Данный оператор полезен для удаления объектов из памяти, когда они не нужны(после удаления объекта или переменной, вы не сможете больше к ним обращаться). Кроме того, оператор del может использоваться для удаления элемента из списка по его индексу или по промежутку:

>>> a

[-1, 1, 66.6, 333, 333, 1234.5]

>>> del a[0]

>>> a

[1, 66.6, 333, 333, 1234.5]

>>> del a[2:4]

>>> a

[1, 66.6, 1234.5]

Константные списки.

Мы до сих пор рассматривали списки, т.е. последовательности, элементы которых могут быть доступны для изменения по отдельности. Другим типом последовательности является константный список(tuple). Такой список в теле программы обозначается списком элементов через запятую, может содержать в себе элементы различных типов, но изменить их через индекс не удастся(см. строки). Константные списки могут содержать в себе в качестве элементов другие последовательности. Для списков константного типа определены операции присваивания, склеивания +, индексации(только чтение). Использовать такие списки удобно при доступе к базам данных(одинаковые поля) и системам координат. Рассмотрим примеры константных списков:

>>> t = 12345, 54321, 'привет!'

>>> t[0]

12345

>>> t

(12345, 54321, 'привет!')

>>> #Вложенный список:

... u = t, (1, 2, 3, 4, 5)

>>> u

((12345, 54321, 'привет!'), (1, 2, 3, 4, 5))#Выходные данные тоже в скобках

Внимание: для создания пустого константного списка просто присвойте ему значение (), для создания списка, состоящего из одного элемента сделайте следующее: “имя_списка = единственный_элемент,” - не забудьте запятую в конце(выглядит не слишком приятно):

>>> empty = ()

>>> singleton = 'привет', # <-- не забыть бы про запятую

>>> len(empty)

0

>>> len(singleton)

1

>>> singleton

('привет',)

Создание константного списка из других переменных, вроде “список = 'привет', 'пока', a” является примером упаковки переменных в константный список. Можно провести обратное действие – распаковку, если такой список присваивается нескольким переменным(их число должно быть равно числу элементов в константном списке):

>>> x, y, z = t

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

Словари.

Во всех рассмотренных последовательностях обращаться к отдельным элементам нужно было по индексу. Иную форму организации последовательности представляют словари. В словарях для доступа к отдельным его элементам используются ключевые индексы, подобные индексам в базах данных. Индексом может быть любой неизменяемый объект, такой как строка, число, константный список(такой список может содержать только строки, числа или другие константные списки). В тексте программы словари задаются фигурными скобками {} с элементами словаря. Каждому элементу словаря должен соответствовать определённый индекс, который отделяется от элемента двоеточием(“индекс:значение”). К элементам словаря можно обращаться по соответствующим им индексам. При обращении к несуществующему индексу возникает ошибка. Чтобы узнать список всех индексов словаря, можно воспользоваться методом keys(), которая возвращает все индексы словаря в случайном порядке(но вы можете отсортировать индексы функцией sort()). Чтобы проверить наличие индекса в словаре, можно использовать метод has_key(). Вот простой пример использования словаря:

>>> tel = {'Ваня': 4098, 'Коля': 4139}

>>> tel['Андрей'] = 4127

>>> tel

{'Коля': 4139, 'Андрей': 4127, 'Ваня': 4098}

>>> tel['Ваня']

4098

>>> del tel['Коля']

>>> tel['Дима'] = 4127

>>> tel

{'Андрей': 4127, 'Дима': 4127, 'Ваня': 4098}

>>> tel.keys()

['Андрей', 'Дима', 'Ваня']

>>> tel.has_key('Ваня')

1

Особенности операторов сравнения.

Теперь, когда мы познакомились со списками, пришёл черёд изучить дополнительные сведения об операторах сравнения. Операторы сравнения (>; <; ==; !=; >=; <=)имеют в выражениях приоритет оценки ниже арифметических операторов, то есть в выражении a + b > c + d * e будут оценены вначале арифметические операции, а затем их результаты будут сравниваться. Операторы сравнения могут комбинироваться друг с другом, например, в выражении “a < b == c” операторы сравнения оцениваются слева направо, так как имеют одинаковый приоритет. Выражения с операторами сравнения могут объединяться с помощью логических операций or(или), and(и) и not(не). Значение логических операторов ясно из названия, поэтому комментарии здесь излишни. Приоритет логических операторов ниже, чем к операторов сравнения, самый высокий приоритет у оператора not, самый низкий – у оператора or. Поэтому, при оценке логических выражений, включающих в себя операторы различного приоритета, встретившееся выражение false может вызвать то, что операторы с более низким приоритетом обработаны не будут.

Для списков существуют особые операторы сравнивания:

оператор in(not in) оценивает, входит ли заданный элемент в последовательность;

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

Результат сравнения может быть присвоен переменной логического типа(принимает значения true и false). В отличие от языка Си, в Питоне не допускаивается присваивание при сравнении, что исключает ошибку, распространённую в языке Си и связанную с употреблением =, вместо ==.

Сравнение списков.

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

(1, 2, 3) < (1, 2, 4)

[1, 2, 3] < [1, 2, 4]

'ABC' < 'C' < 'Pascal' < 'Python'

(1, 2, 3, 4) < (1, 2, 4)

(1, 2) < (1, 2, -1)

(1, 2, 3) == (1.0, 2.0, 3.0)

1. 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)

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

Модули в Питоне.

Работая в интерактивном режиме интерпретатора, вы, наверное, решили, что писать большие программы в Питоне невозможно, так как после выхода из интерпретатора определения ваших функций “исчезают” бесследно. А хотелось бы иметь возможность написать несколько функций в одном файле и потом иметь возможность обращаться к ним из других программ(принцип повторного использования кода). Такая возможность в Питоне существует. Это технология модулей, то есть текстовых файлов, содержащих в себе какой-либо набор функций(желательно объединённых по какому-либо признаку). Большинство функций стандартной библиотеки Питона реализовано именно в модулях. Создать модуль очень просто: просто зайдите в свой любимый текстовый редактор, напишите определения своих функций с помощью ключевого слова def, не забывайте также об отступах, которые выделяют блоки в программе. Ставить символы >>> и .... в текстовом редакторе нельзя, так как это вызовет синтаксическую ошибку. Модули Питона имеют расширение .py и могут содержать только текст. Внутри модуля существует глобальная переменная __name__, в которой содержится имя текущего модуля. Напрмер, создайте файл с именем fibo.py, содержащим следующий код:

#Модуль Фибоначчи

def fib(n): # выводит числа Фибоначчи на экран

a, b = 0, 1

while b < n:

print b,

a, b = b, a+b

def fib2(n): # возвращает числа Фибоначчи, не превосходящие n

result = []

a, b = 0, 1

while b < n:

result.append(b)

a, b = b, a+b

return result

Сохраните файл и зайдите в интерпретатор Питона. К функциям из модуля можно получить доступ посредством ключевого слова import имя_модуля:

>>> import fibo

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

>>> fibo.fib(1000)

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

>>> fibo.fib2(100)

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

>>> fibo.__name__

'fibo'

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

>>> fib = fibo.fib

>>> fib(500)

1 1 2 3 5 8 13 21 34 55 89 144 233 377

Дополнительная информация о модулях.

Модули могут содержать в себе кроме определений функций и некоторый исполняемый код. Этот код не входит ни в какую функцию и исполняется интерпретатором, когда данный модуль подключается ключевым словом import. В исполняемом коде модуля можно использовать любые переменные, которые внутри модуля объявляются глобальными. Но каждый модуль имеет собственную таблицу переменных, так что случайное изменение таких переменных вне модуля исключено. Такой механизм обеспечивает стабильность работы модуля и соответствует принципу сокрытия информации.

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

Из модуля можно импортировать не все, а только необходимые в данной ситуации функции(или иные объекты), тогда оператор import будет выглядеть так:

>>> from fibo import fib, fib2

>>> fib(500)

1 1 2 3 5 8 13 21 34 55 89 144 233 377

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

>>> from fibo import *

>>> fib(500)

1 1 2 3 5 8 13 21 34 55 89 144 233 377

Информация о поиске модулей.

Когда вы импортируете модуль, то Питон ищет файл с таким именем не где-нибудь, а в определённых каталогах. Эти каталоги определены в переменной окружения PYTHONPATH вашей операционной системы. Эта переменная имеет структуру, схожую с переменной PATH и так же содержит в себе каталоги, где Питон будет искать модули. При отсутствии этой переменной, Питон будет искать модули в папке, куда были установлены его исполняемые файлы, а так как этот каталог зависит от инсталляции и частенько никаких модулей в нём нет, то удалять или изменять без особой необходимости PYTHONPATH не следует. Доступ к списку каталогов поиска можно получить также из списка sys.path модуля sys(import sys). Этот список можно изменять программно, путём стандартных операций со списками. Ни в коем случае не называйте свои модули так же, как названы стандартные модули Питона, так как это повлечёт за собой труднообнаружимую ошибку. Если подлежащий импорту скрипт находится в том же каталоге, что и вызывающая его программа, то нет необходимости обращаться к sys.path, так как Питон ищет модули также и в текущей директории.

Компиляция скриптов на Питоне.

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

Стандартные модули Питона.

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

В модулях содержатся некоторые функции, позволяющие настраивать интерпретатор. Это в основном функции и переменные модуля sys. Например, переменные sys.ps1 и sys.ps2 хранят в себе приглашение интерпретатора:

>>> import sys

>>> sys.ps1

'>>> '

>>> sys.ps2

'... '

>>> sys.ps1 = '[Python@localhost]# '

[Python@localhost]# print 'Ой!'

Ой!

[Python@localhost]#

Список sys.path хранит в себе пути поиска библиотек интерпретатором:

>>> import sys

>>> sys.path.append('/home/guido/lib/python')

Встроенная функция dir([имя_модуля]) позволяет вывести все загруженные модули, может также вывести все объекты какого-либо конкретного модуля(с указанием имени модуля, в качестве аргумента dir()):

>>> import fibo, sys

>>> dir(fibo)

['__name__', 'fib', 'fib2']

>>> dir(sys)

['__displayhook__', '__doc__', '__excepthook__', '__name__', '__stderr__',

'__stdin__', '__stdout__', '_getframe', 'argv', 'builtin_module_names',

'byteorder', 'copyright', 'displayhook', 'exc_info', 'exc_type',

'excepthook', 'exec_prefix', 'executable', 'exit', 'getdefaultencoding',

'getdlopenflags', 'getrecursionlimit', 'getrefcount', 'hexversion',

'maxint', 'maxunicode', 'modules', 'path', 'platform', 'prefix', 'ps1',

'ps2', 'setcheckinterval', 'setdlopenflags', 'setprofile',

'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout', 'version',

'version_info', 'warnoptions']

Встроенные функции Питона содержатся в модуле __builtin__(импортировать его для использования функций не нужно):

>>> import __builtin__

>>> dir(__builtin__)

['ArithmeticError', 'AssertionError', 'AttributeError',

'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError',

'Exception', 'FloatingPointError', 'IOError', 'ImportError',

'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt',

'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented',

'NotImplementedError', 'OSError', 'OverflowError', 'OverflowWarning',

'ReferenceError', 'RuntimeError', 'RuntimeWarning', 'StandardError',

'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError',

'SystemExit', 'TabError', 'TypeError', 'UnboundLocalError',

'UnicodeError', 'UserWarning', 'ValueError', 'Warning',

'ZeroDivisionError', '_', '__debug__', '__doc__', '__import__',

'__name__', 'abs', 'apply', 'buffer', 'callable', 'chr', 'classmethod',

'cmp', 'coerce', 'compile', 'complex', 'copyright', 'credits', 'delattr',

'dict', 'dir', 'divmod', 'eval', 'execfile', 'exit', 'file', 'filter',

'float', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id',

'input', 'int', 'intern', 'isinstance', 'issubclass', 'iter', 'len',

'license', 'list', 'locals', 'long', 'map', 'max', 'min', 'object',

'oct', 'open', 'ord', 'pow', 'property', 'quit', 'range', 'raw_input',

'reduce', 'reload', 'repr', 'round', 'setattr', 'slice', 'staticmethod',

'str', 'super', 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange',

'zip']

Пакеты.

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

Sound/ Корневой пакет

__init__.py Инициализация звуковой библиотеки

Formats/ Подпакет звуковых форматов

__init__.py

wavread.py

wavwrite.py

aiffread.py

aiffwrite.py

auread.py

auwrite.py

...

Effects/ Подпакет звуковых эффектов

__init__.py

echo.py

surround.py

reverse.py

...

Filters/ Подпакет фильтров

__init__.py

equalizer.py

vocoder.py

karaoke.py

...

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

Файл __init__.py нужен интерпретатору для того, чтобы расценивать каталог на диске, как пакет. Данный файл может быть пустым, но может содержать исполняемый код, для инициализации переменной __all__.

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

1. import Sound.Effects.echo

Загрузка модуля echo. Далее должно указываться полное имя модуля.:

Sound.Effects.echo.echofilter(input, output, delay=0.7, atten=4)

2. from Sound.Effects import echo

Также загрузка модуля echo, но теперь к нему можно обращаться без указания имени модуля:

echo.echofilter(input, output, delay=0.7, atten=4)

3. from Sound.Effects.echo import echofilter

Прямой импорт объекта из пакета. Теперь вы можете обращаться к функции echofilter() непосредственно через её имя:

echofilter(input, output, delay=0.7, atten=4)

Из пакетов можно также импортировать все модули. Но трюк с import * не пройдёт на некоторых операционных системах(DOS, Windows, MAC), так как в них не различается регистр у файлов и папок, а так как в Питоне регистр различается, то это может привести к непредсказуемым именам модулей(Echo, echo, ECHO, eChO). Поэтому для надёжности лучше создавать список модулей пакета в файле __init__.py. Для этого присвойте переменной __all__ список всех имён модулей(строковый тип элемента списка). Такой подход обеспечит корректную интерпретацию пакета на любой системе.

__all__ = ["echo", "surround", "reverse"]

А в самом коде можно теперь применять import *:

from Sound.Effects import *

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

Форматированный ввод/вывод.

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

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

В Питоне имеется несколько способов форматированного ввода/вывода. Самый простой из них – оператор print, печатающий переменные и строковые константы, применяя формат по умолчанию. Другой простой способ вывода данных на дисплей – функция str(), которая выводит любую переменную, используя также формат по умолчанию. Есть также функция repr(), которая выводит данные в машинном(неформатированном) виде. Некоторые типы переменных, которые не могут должным образом отформатироваться функцией str(), обрабатываются схоже с repr(). Пример использования функций str() и repr():

>>> s = 'Hello, world.'

>>> str(s)

'Hello, world.'

>>> `s`#Такое выражение значит то же, что и repr(s)

"'Hello, world.'"#Машинный формат

>>> str(0.1)#Переменная с точкой

'0.1'

>>> `0.1`# repr(0.1)

'0.10000000000000001'#Ошибка округления чисел с точкой

>>> x = 10 * 3.25

>>> y = 200 * 200

>>> s = 'Значение x равно' + `x` + ', а y равен ' + `y` + '...'#Использование операций склеивания

... #строк для форматирования

>>> print s

Значение x равно 32.5, а y равен 40000...

>>> #Заключение переменных в кавычки работает для всех типов данных

... p = [x, y]

>>> ps = repr(p)

>>> ps

'[32.5, 40000]'

>>> # Окружение строки дополнительными кавычками

... hello = 'hello, world\n'

>>> hellos = `hello`

>>> print hellos

'hello, world\n'

>>> # Можно заключать в кавычки и константные списки

... `x, y, ('Linux', 'BSD')`

"(32.5, 40000, ('Linux', 'BSD'))"

Для форматированного вывода удобно использовать выравнивание по краю. Для этой цели в Питоне предусмотрены следующие функции модуля string: string.rjust(), string.ljust() и string.center(). Эти функции возвращают выровненную строку по правому и левому краю, а также по центру до определённого количества символов. Они принимают два параметра: саму строку и количество символов, зарезервированных под строку(если строка длинее, то она выводится как есть, а для удаления лишних символов воспользуйтесь “string.ljust(x, n)[0:n]#”). На примере это выглядит так:

>>> import string

>>> for x in range(1, 11):

... print string.rjust(`x`, 2), string.rjust(`x*x`, 3),

... # В предыдущем операторе print была поставлена в конце запятая, перевода строки нет:

... print string.rjust(`x*x*x`, 4)

...

1 1 1

2 4 8

3 9 27

4 16 64

5 25 125

6 36 216

7 49 343

8 64 512

9 81 729

10 100 1000

Для этой же цели можно использовать оператор print со строкой формата, аналогичной Си:

>>> for x in range(1,11):

... print '%2d %3d %4d' % (x, x*x, x*x*x)# %d означает целое число

...

1 1 1

2 4 8

3 9 27

4 16 64

5 25 125

6 36 216

7 49 343

8 64 512

9 81 729

10 100 1000

Очевидно, что число после символа процента определяет количество символов для выравнивания. Спецификатор после процента обозначает тип числа:

Функция string.zfill() возвращает строку, дополненную нулями слева, если её длина меньше заданной. string.zfill(строка, заданная_ширина):

>>> import string

>>> string.zfill('12', 5)

'00012'

>>> string.zfill('-3.14', 7)

'-003.14'

>>> string.zfill('3.14159265359', 5)

'3.14159265359'

Если использовать оператор print, то можно для той же цели использовать конструкцию “%ширина_поля.число_знаков_после_запятой”:

>>> import math

>>> print 'Значение числа Пи приблизительно %5.3f.' % math.pi

Значение числа Пи приблизительно 3.142.

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

>>> table = {'Иван': 4127, 'Жека': 4098, 'Илья': 7678}

>>> for name, phone in table.items():

... print '%-10s ==> %10d' % (name, phone)

...

Иван ==> 4098

Жека ==> 7678

Илья ==> 4127

Для оператора print можно передавать аргументы не по порядку в строке формата, а по именам переменных, описанных в строке формата следующим образом “%(имя_переменной)тип_переменной”:

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}

>>> print 'Jack: %(Jack)d; Sjoerd: %(Sjoerd)d; Dcab: %(Dcab)d' % table

Jack: 4098; Sjoerd: 4127; Dcab: 8637678

Операции с файлами.

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

• Метод open(имя, режим). Открывает файловый объект для последующего оперирования с ним. Функция принимает два параметра: строку, содержащую путь к файлу(может быть абсолютным или относительным текущего каталога или переменной окружения PATH) и режимом открытия файла. Режим открытия файла определяет допустимые операции доступа к файлу:

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

>>> f=open('/tmp/workfile', 'w')

>>> print f

<open file '/tmp/workfile', mode 'w' at 80a0960>

• Метод read([число_байт]). Данный метод читает из файла, открытого для чтения число байтов, указанных в качестве аргумента. Если метод вызывается без параметров, то читается весь файл, если файл был прочитан до конца(встретился символ EOF), то метод read() возвращает пустую строку:

  >>> f.read()

  'This is the entire file.\n'

  >>> f.read()

  ''

• Метод readline() читает одну строку файла до символа перевода строки(включая сам символ \n). Если строка состоит только из символа перевода строки, то метод readline() возвращает пустую строку. Если в конце файла нет пустой строки с символом \n, то возвращаемый результат неопределён(этого допускать нельзя):

  >>> f.readline()

  'This is the first line of the file.\n'

  >>> f.readline()

  'Second line of the file\n'

  >>> f.readline()

  ''

• Метод readlines([размер_строки]) читает все строки файла в список. Читаются только законченные строки. Необязательный параметр размер_строки дополняет читает строку, и если она меньше указанной длины читает дальше, до достижения указанного числа символов, такой приём эффективен для чтения очень больших файлов построчно без необходимости размещения его в памяти:

  >>> f.readlines()

  ['This is the first line of the file.\n', 'Second line of the file\n']

• Метод write(строка) пишет в файл указанную строку, ничего при этом не возвращая:

  >>> f.write('This is a test\n')

• Метод seek(на_сколько_байт[, откуда]) перемещает указатель текущего положения файла на заданное количество байт от позиции, указанной вторым аргументом:

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

• Метод tell() возвращает текущую позицию в файле:

  >>> f=open('/tmp/workfile', 'r+')

  >>> f.write('0123456789abcdef')

  >>> f.seek(5) # Переход к шестому байту от начала

  >>> f.read(1)

  '5'

  >>> f.seek(-3, 2) # Переход к третьему байту до конца файла

  >>> f.read(1)

  'd'

• Метод close() закрывает объект файла, перенося все сделанные в нём изменения на диск, возвращая ресурсы операционной системе. Обязательно закрывайте все файлы, сто больше не используете, т.к. не закрытый файл может привести к потере данных. После закрытия обращение к объекту файла автоматически вызывает ошибку

Модуль pickle.

Для чтения/записи в файл используются строки. То есть вам необходимо прежде чем записать что-либо в файл преобразовать это что-то в строку. С числовыми значениями всё легко: в модуле string есть множество функций для преобразования чисел в строки и строк в числа(например, строка в целое “string.atoi()”). Но как быть со сложными объектами: списками, например. Для этой цели в Питоне существует особый модуль: pickle, который может преобразовать в строку любой объект(даже некоторый формат кода самого Питона!) и записать его в файл. При этом при помощи модуля pickle можно выполнить обратную операцию из строки, генерированной pickle, в переменную(модуль сам распознает её тип). Причём, функционирование модуля pickle одинаково в любой реализации Питона, поэтому использование подобного механизма способствует переносимости кода и помогает повторно использовать какие-либо сложные объекты. Пример использования модуля pickle(полное описание я пока не перевёл):

pickle.dump(x, f)#Выгрузка содержимого x в файл f

x = pickle.load(f)#Загрузка x из файла f.

Ошибки и исключения.

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

Синтаксические ошибки.

Ошибки такого типа обычно находятся интерпретатором:

>>> while 1 print 'Hello world'

File "<stdin>", line 1, in ?

while 1 print 'Hello world'

^

SyntaxError: invalid syntax #Неверный синтаксис команды

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

Исключительные ситуации.

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

>>> 10 * (1/0)

Traceback (most recent call last):

File "<stdin>", line 1, in ?

ZeroDivisionError: integer division or modulo #Деление на нуль

>>> 4 + spam*3

Traceback (most recent call last):

File "<stdin>", line 1, in ?

NameError: spam

#Нет такого имени переменной

>>> '2' + 2

Traceback (most recent call last):

File "<stdin>", line 1, in ?

TypeError: illegal argument type for built-in operation#Смешение разных типов

Конечно, всё было бы отлично, если пользователя удовлетворяли подобные сообщения, я лично в этом сильно сомневаюсь. Кроме этого, исключения могут генерировать ся в любой момент программы, что может вызвать потерю данных. По всем этим причинам желательно предусматривать возможность перехватывать исключения. Для этого используется блок try, который исполняет операторы внутри блока, но если возбуждается исключение, то оператор try ищет обработчик исключения(прерывая исполнение блока кода внутри try), обозначаемый except имя_исключения . Если обработчик не найден, то он ищется в других блоках try, если он не найден, то возникает непредвиденное(unhandled) исключение, которое отображается, как в предыдущем примере. Блок try выполняется до конца при отсутствии исключительных ситуаций, блоки except при этом пропускаются:

>>> while 1:

... try:

... x = int(raw_input("Введите число ")) #Здесь может возникнуть исключение

... break #Если всё правильно, то выходим из бесконечного while

... except ValueError: #А вот здесь обрабатывается исключение неверного формата числа

... print ''Ой-ой. Неправильное число. Попробуйте снова..."

Оператор except может принимать несколько имён исключений, оформленных в скобках через запятую:

... except (RuntimeError, TypeError, NameError):

... pass

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

import string, sys

try:

f = open('myfile.txt')

s = f.readline()

i = int(string.strip(s))

except IOError, (errno, strerror):

print "I/O ошибка(%s): %s" % (errno, strerror)

except ValueError:

print "Не могу преобразовать это в целое."

except:

print "Неожиданная ошибка:", sys.exc_info()[0] #Имя последнего исключения

raise #Возбуждение данного исключения ещё раз(см. далее)

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

for arg in sys.argv[1:]:

try:

f = open(arg, 'r')

except IOError:

print 'не могу открыть', arg

else:

print arg, 'имеет длину в ', len(f.readlines()), ' строк'

f.close()

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

>>> def this_fails():

... x = 1/0

...

>>> try:

... this_fails() #Функция, вызывающая исключительную ситуацию

... except ZeroDivisionError, detail:

... print 'Возбуждено исключение:', detail

...

Возбуждено исключение: integer division or modulo

Программное возбуждение исключений.

Если вы пишете библиотеки функций, то одним из способов сообщить вызывающей программе о том, что случилась непредвиденная ситуация, является возбуждения исключений. Для этой цели используется оператор raise, который возбуждает заданное исключение. Оператор raise имеет следующий синтаксис: raise имя_исключения[, аргумент_исключения, аргумент_исключения ...]. Если raise вызывается без аргументов, то она возбуждает повторно самое последнее исключение:

>>> raise NameError, 'HiThere'

Traceback (most recent call last):

File "<stdin>", line 1, in ?

NameError: HiThere

raise без параметров часто используется в промежуточных обработчиках исключений:

>>> try:

... raise NameError, 'HiThere'

... except NameError:

... print 'Произошла ошибка!'

... raise

...

Произошла ошибка!

Traceback (most recent call last):

File "<stdin>", line 2, in ?

NameError: HiThere

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

Заключительные действия.

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

>>> try:

... raise KeyboardInterrupt

... finally:

... print 'Goodbye, world!'

...

Goodbye, world!

Traceback (most recent call last):

File "<stdin>", line 2, in ?

KeyboardInterrupt

__finally блок выполняется независимо от того произошло исключение или нет, если исключение произошло, то оно возбуждается ещё раз. Оператор try может иметь или блоки except или __finally, но не одновременно. Блок __finally выполняется даже во вложенных try, поэтому использование вложенных try(с except) и внешнего с __finally способно отловить и корректно обработать любые возникшие исключения.

Классы.

Введение в объектно-ориентированное программирование.

Мы живём в мире объектов. Нас окружают различные предметы, они имеют определённые свойства: цвет, объём, вкус. Предметы могут выполнять различные действия, например, мячик может прыгать по столу. Объекты между собой взаимосвязаны, например, мячик взаимодействует со столом, когда прыгает по нему. Мы сразу же отличаем футбольный, волейбольный, баскетбольный и детский надувной мячи, но всех их мы называем общим понятием “мяч”, представляя у себя в уме некий образ мяча (идеальный шар), хотя реальный предмет может быть совсем не похожим на тот идеальный образ. Это пример наследования в реальном мире. Мы переходим от образа ко всё более конкретным объектам: образ – материальный предмет – фигура – шар – мяч – волейбольный мяч – профессиональный волейбольный мяч – мяч Николая Синего. При этом не исключается потомки у всех элементов цепи, то есть соблюдается принцип ветвления. Некоторые свойства мяча могут совершаться по-разному, что иллюстрирует принцип полиморфизма (своеобразная эволюция объектов). При этом мы не можем создать идеальный шар (поверхность любого “реального” шара не совсем ровная), есть некоторые понятия, которые являются абстрактными, их нельзя воссоздать в реальной жизни по причине ширины охвата других понятий(очень общее понятие), но можно создать другие, объекты, произошедшие от данного, но являющиеся более конкретными. В программировании такой подход в настоящее время получил наиболее широкое распространение. Ведь человек (а программисты в большинстве своём люди) проще понимают то, что видят, но это, как говорил Ходжа Насреддин:“Тонкий философский вопрос”. То есть человек понимает только тот подход, к которому он привык в реальной жизни. При создании серьёзных программных проектов объектный подход является единственным приемлемым, так как упрощает понимание общей структуры программы. Объектный подход, как и разбиение программы на модули(структурный подход) стремятся обеспечить сокрытие информации, дабы не копаться в коде программы, чтобы определить, что она делает, а взглянуть на определения функций и понять как они работают. Нам ведь часто не интересно, как там общается программа с прерываниями центрального процессора, мы просто вызываем функцию считывания значения из консоли. При создании классов(именно так называются объекты в программировании) мы избавляем конечного пользователя от возни с разбором кода, а показываем ему структурную схему классов. Естественно в небольших программах выгоды от использования классов нет никакой(недостаток языка Java), но в крупных проектах они необходимы, как воздух.

Итак, вернёмся с небес на землю, то есть к Питону. В языке Питон использование классов является необязательным, но они реализованы по такому же принципу, как классы Си++(не все системные типы являются классами, в отличие от языка Java). В Питоне присутствует полная поддержка классов. Но в Питоне объекты класса создаются и уничтожаются автоматически, то есть вам не нужно для этой цели создавать особые методы. Внутри класса могут переопределяться любые стандартные операторы. Но обо всём по порядку.

Области действия переменных.

В технологии классов важную роль играет область действия переменной. Вы можете обращаться к переменной только внутри блока, где она была определена(в первый раз использована). Если переменная была определена внутри функции, то вне функции к ней нет доступа, если функция определена в основном коде, то она становится глобальной для данной программы(файла-модуля). Но если переменная или функция определена внутри модуля, то обращаться к ней непосредственно по имени невозможно(см.модули). Для обращения к переменной, находящейся внутри модуля, вне модуля чаще всего используется синтаксис имя_модуля.имя_переменной. Для обращения к переменной внутри данной программы, можно воспользоваться модулем главной программы __main__, все переменные и методы, объявленные в различных модулях создаются и разрушаются в определённом порядке. Например, когда вы импортируете модуль, то создаются все объекты, объявленные в нём. Для встроенных функций интерпретатора имеется также особый модуль __builtin__, объекты данного модуля создаются при запуске и не уничтожаются никогда, то есть время жизни таких объектов распространяется на всю программу. Если вы объявляете переменную в функции, цикле, операторе выбора, то она доступна только внутри блока, в котором была объявлена. Если вы хотите объявить глобальную переменную, то воспользуйтесь ключевым словом global. И последнее, о чём я хотел упомянуть в рамках данного раздела, это физические особенности переменных в Питоне. Переменные, естественно, хранятся в памяти компьютера, но имя переменной, это фактически символическая ссылка на ячейку памяти. Поэтому, когда вы присваиваете одной переменной другую, то они фактически указывают на один и тот же объект. При изменении одной переменной, изменяется и другая. Поэтому надо всегда быть осторожным с такого рода операциями.

Первое знакомство с классами.

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

class имя_класса:

элемент_класса_1

.

.

.

элемент_класса_n

Объявление класса напоминает использование ключевого слова def для функции, пока класс не объявлен, использовать его запрещено. Класс может быть описан внутри функции или структуры if, но всё же желательнее описывать класс вне программных структур, то есть в теле программы, а ещё лучше описать все классы в самом начале программы, так как это облегчает чтение программы. Класс, будучи объявлен, создаёт в программе новую область действия, поэтому всё, описанное внутри класса, включается в область действия класса и является недоступным извне. Обычно класс состоит в основном из функций элементов, они определяются внутри класса словом def. Функции-элементы класса имеют некоторые особенности списка аргументов(об этом будет сказано далее).

К объектам классов в Питоне можно обращаться двумя способами: ссылкой на элемент(имя_класса.имя_элемента) и через присвоение переменной класса через функцию(переменная = имя_класса()), например:

class MyClass:

"Простой класс"

i = 12345

def f(self):

return 'Привет мир'

x = MyClass()

Такое объявление присваивает переменной х объект класса MyClass и теперь ко всем элементам данного класса можно обращаться через данную переменную. Причём область действия данного объекта совпадает с областью действия переменной х. Следует отметить особый параметр self, который передаётся функции класса. Этот параметр является типичным для функций-элементов класса, так как содержит ссылку на класс, которому принадлежит данная функция и позволяет обращаться к другим членам класса.

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

def __init__(self):

self.data = []

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

>>> class Complex:

... def __init__(self, realpart, imagpart):

... self.r = realpart

... self.i = imagpart

...

>>> x = Complex(3.0, -4.5)

>>> x.r, x.i

(3.0,-4.5)

Обращение к элементам классов.

Обращение через ссылку.

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

x.counter = 1

while x.counter < 10:

x.counter = x.counter * 2

print x.counter

del x.counter

При присваивании переменной ссылки на метод класса, как например:

xf = x.f

while 1:

print xf()

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

Наследование.

Одиночное наследование.

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

Синтаксис класса, наследующего одному классу:

class имя_наследуемого_класса(имя_класса_родителя):

элемент_класса_1

.

.

.

элемент_класса_n

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

class имя_наследуемого_класса(имя_модуля.имя_класса_родителя):

элемент_класса_1

.

.

.

элемент_класса_n

Для обращения к элементам и методам родительского класса используется синтаксис: имя_родителя.имя_поля или имя_родителя.имя_метода(аргументы).

Множественное наследование.

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

class имя_наследуемого_класса(имя_класса_родителя1, имя_класса_родителя2, ... имя_класса_родителяN):

элемент_класса_1

.

.

.

элемент_класса_n

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

Закрытые переменные.

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

Если вы объявляете какой-либо элемент, начиная его с двойного подчёркивания, то он автоматически становится закрытым и обращение к нему вне класса вызывает синтаксическую ошибку, в то время как обращение через self является приемлемым:

>>> class Test2:
... __foo = 0
... def set_foo(self, n):
... if n > 1:
... self.__foo = n

... print self.__foo
...
>>> x = Test2()

>>> x.set_foo(5)

5
>>> x.__foo
Traceback (most recent call last):
File "<interactive input>", line 1, in ?
AttributeError: Test2 instance has no attribute '__foo'

Кроме этого закрытой является также переменная, содержащаяся в любом модуле __dict__.

Структуры.

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

class Employee:

pass

john = Employee() # Создание пустой структуры

# Создаём и заполняем поля структуры

john.name = 'Иван Иванович'

john.dept = 'Программист'

john.salary = 100000

Исключения и классы.

Все исключения являются классами. Чтобы определить новый тип исключения, мы фактически создаём новый класс, наследующий базовому классу Exception:

>>> class MyError(Exception):

... def __init__(self, value):

... self.value = value

... def __str__(self):

... return `self.value`

...

>>> try:

... raise MyError(2*2)

... except MyError, e:

... print 'My exception occurred, value:', e.value

...

My exception occurred, value: 4

>>> raise MyError, 'oops!'

Traceback (most recent call last):

File "<stdin>", line 1, in ?

__main__.MyError: 'oops!'

Обычно в классах-исключениях делают небольшие конструкторы __init__, которые инициализируют поля класса, чтобы к ним впоследствие можно было бы обратиться:

class Error(Exception):

"""Базовый класс для исключений в модуле."""

pass

class InputError(Error):

"""Ошибка ввода данных.

Поля:

expression – выражение, где произошла ошибка

message – объяснение ошибки

"""

def __init__(self, expression, message):

self.expression = expression

self.message = message

class TransitionError(Error):

"""Возникает при неверной операции

Поля:

previous – состояние до начала плохой операции

next – состояние после операции

message – объяснение, почему такая операция недопустима

"""

def __init__(self, previous, next, message):

self.previous = previous

self.next = next

self.message = message

Вверх: Оглавление Вперёд: Синтаксис языка Питон

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

Питон – это объектно-ориентированный, интерпретируемый, переносимый язык сверхвысокого уровня. Программирование на Питоне позволяет получать быстро и качественно необходимые программные модули. Интерпретатор Питона может быть перенесён на любую платформу, будь то 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. Например, простейшая программа Hello World печатается в Питоне совсем просто:

>>print “Hello World”

Hello World

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

>>> 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

Некоторые полезные функции и константы для работы со строками.

Для использования функций и констант модуля строк необходимо включить его прямой командой import string (см. главу о модулях).

ascii_lowercase и ascii_uppercase содержат в себе набор латинских букв соответственно нижнего и верхнего регистров

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

digits, hexdigits, octdigits содержат в себе цифры десятичные, шестнадцатицентричные и восьмеричные

punctuation содержит в себе знаки пунктуации текущей локальной установки

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

uppercase и lowercase содержат в себе заглавные и маленькие буквы текущей локальной установки

whitespace содержит в себе символы, которые в текущей локальной установке считаются пробельными(пробел, табуляция, перевод строки).

Функции:

float(число_с_запятой) конвертирует число с плавающей запятой в строку, при

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

Строки Юникода 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

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

Упражнения:

1. Написать программу, считывающую 2 числа и выводящую их сумму. Указание: для ввода числа с клавиатуры используйте функцию raw_input([подсказка]), чтобы привести данные с клавиатуры используйте функцию int(raw_input()).

2. Написать программу, находящую число перекладываний для ханойской башни из n дисков(кто ничего не слышал о ханойской башне, могут пропустить это задание), которое вычисляется по формуле 2^n – 1. Указание: для возведения в степень используйте функцию pow(основание, показатель).

3. Написать программу, подсчитывающую сумму n членов арифметической прогрессии с первым членом q и разностью d(воспользуйтесь для этого циклом while).

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

5. Напишите программу, выводящую на экран изображение шахматной доски. Воспользуйтесь 2-мя операторами print и одним оператором while

   * * * * * * * *

   * * * * * * * *

   * * * * * * * * ...

   Ну вот и всё пока.

Модуль sys.

Данный модуль обеспечивает высокоуровневое взаимодействие с операционной системой. Но не для всех ОС пригодны некоторые функции. Если не оговорено особо – функция работает во всех ОС. Перечень наиболее употребительных функций и переменных модуля:

>>> import sys
>>> sys.version
'1.5.2 (#0 Apr 13 1999, 10:51:12) [MSC 32 bit (Intel)]'