Файл: Общие характеристики скриптовых языков. Язык Python.pdf

1.Введение.

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

В связи с этим, определенный интерес представляет рассмотрение сравнительно нового языка программирования Python (пайтон), который был создан его автором Гвидо ван Россумом (Guido van Rossum) в начале 90-х годов.

2.Общие сведения о Python. Достоинства и недостатки.

Python является интерпретируемым, изначально объектно-ориентированным языком программирования. Он чрезвычайно прост и содержит небольшое число ключевых слов, вместе с тем очень гибок и выразителен. Это язык более высокого уровня, нежели Pascal, C++ и, естественно C, что достигается, в основном, за счет встроенных высокоуровневых структур данных (списки, словари, тьюплы).

2.1Достоинства языка.

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

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

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

• Numerical Python - расширенные математические возможности, такие как манипуляции с целыми векторами и матрицами;
• Tkinter - построение приложений с использованием графического пользовательского интерфейса (GUI) на основе широко распространенного на X-Windows Tk-интерфейса;
• OpenGL - использование обширной библиотеки графического моделирования двух- и трехмерных объектов Open Graphics Library фирмы Silicon Graphics Inc. Данный стандарт поддерживается, в том числе, в таких распространенных операционных системах как Microsoft Windows 95 OSR 2, 98 и Windows NT 4.0.

2.2Недостатки языка.

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

3.Обзор особенностей.

1. Python, в отличие от многих языков (Pascal, C++, Java, и т.д.), не требует описания переменных. Они создаются в месте их инициализации, т.е. при первом присваивании переменной какого-либо значения. Значит, тип переменной определяется типом присваиваемого значения. В этом отношении Python напоминает Basic.

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

2. В таких языках как Pascal, C, C++ организация списков представляла некоторые трудности. Для их реализации приходилось хорошо изучать принципы работы с указателями и динамической памятью. И даже имея хорошую квалификацию, программист каждый раз заново реализуя механизмы создания, работы и уничтожения списков, мог легко допустить трудноуловимые ошибки. Ввиду этого были созданы некоторые средства для работы со списками. Например, в Delphi Pascal имеется класс TList, реализующий списки; для С++ разработана библиотека STL (Standard Template Library), содержащая такие структуры как векторы, списки, множества, словари, стеки и очереди. Однако такие средства имеются не во всех языках и их реализациях.

Одной из отличительных черт Python является наличие таких встроенных в сам язык структур как тьюплы (tuple), списки (list) и словари (dictionary), которые иногда называют картами (map). Рассмотрим их подробней.

1. Тьюпл. Он чем-то напоминает массив: состоит из элементов и имеет строго определенную длину. Элементами могут быть любые значения - простые константы или объекты. В отличие от массива, элементы тьюпла не обязательно однородны. А тем, что отличает тьюпл от списка (list) является то, что тьюпл не может быть изменен, т.е. мы не можем i-тому элементу тьюпла присвоить что-то новое, и не можем добавлять новые элементы. Таким образом, тьюпл можно назвать списком-константой. Синтаксически тьюпл задается путем перечисления через запятую всех элементов, и все это заключено в круглые скобки:

(1, 2, 5, 8)

(3.14, ‘ string ’, -4)

Все элементы индексируются с нуля. Для получения i-го элемента необходимо указать имя тьюпла затем индекс i в квадратных скобках. Пример:

t = (0,1,2,3,4)

print t[0], t[-1], t[-3]

Результат: 0 4 2

Таким образом, тьюпл можно было назвать вектором-константой, если бы его элементы всегда были однородными.

1. Список. Хорошим, частным примером списка может служить строка (string) языка Turbo Pascal. Элементами строки являются одиночные символы, ее длина не фиксирована, имеется возможность удалять элементы или, напротив, вставлять их в любом месте строки. Элементами же списка могут быть произвольные объекты не обязательно одного и того же типа. Чтобы создать список, достаточно перечислить его элементы через запятую, заключив все это в квадратные скобки:

[3, 5.14, ‘s’]

[‘string’, (0,1,8), [1,1]]

В отличие от тьюпла, списки можно модифицировать по своему желанию. Доступ к элементам осуществляется также как и в тьюплах. Пример:

l = [1, ‘s’, (2,8), [0,3,4]]

print l[0], l[1], l[-2], l[-1][0]

Результат: 1 s (2,8) 0

1. Словарь. Напоминает тип запись (record) в Pascal или структуры (structure) в С. Однако, вместо схемы «поле записи»-«значение» здесь применяется «ключ»-«значение». Словарь представляет собой набор пар «ключ»-«значение». Здесь «ключ» - константа любого типа (но преимущественно применяются строки), он служит для именования (индексирования) некоторого соответствующего ему значения (которое можно менять). Словарь создается путем перечисления его элементов (пар "ключ"-"значение", разделенных двоеточием), через запятую и заключения всего этого в фигурные скобки. Для получения доступа к некоторому значению необходимо, после имени словаря, записать соответствующий ключ. Пример:

d = {'a': 1, 'b': 3, 5: 3.14, 'name': 'John'}

d['b'] = d[5]

print d['a'], d['b'], d[5], d['name']

Результат: 1 3.14 3.14 John

Для добавления новой пары "ключ"-"значение" достаточно присвоить элементу с новым ключом соответствующее значение:

d['new'] = 'new value'

print d

Результат: {'a':1, 'b':3, 5:3.14, 'name':'John', 'new':'new value'}

3. Python в отличие от Pascal, C, C++ не поддерживает работу с указателями, динамической памятью и адресную арифметику. В этом он похож на Java. Как известно, указатели служат источником трудноуловимых ошибок, и работа с ними относится больше к программированию на низком уровне. Для обеспечения большей надежности и простоты они небыли включены в Python.

4. Одним из особенностей Python является то, как происходит присваивание одной переменной другой, т.е. когда по обе стороны от оператора "=" стоят переменные.

Следуя Тимоти Бадду ([1]), будем называть семантикой указателей случай, когда присваивание приводит лишь к присваиванию ссылки (указателя), т.е. новая переменная становится лишь другим именем, обозначающим тот же участок памяти что и старая переменная. При этом изменение значения, обозначаемого новой переменной, приведет к изменению значения старой, т.к. они, фактически, означают одно и то же.

Когда же присваивание приводит к созданию нового объекта (здесь объект - в смысле участка памяти для хранения значения какого-либо типа) и копированию в него содержимого присваиваемой переменной, этот случай назовем семантикой копирования. Таким образом, если при копировании действует семантика копирования, то переменные по обе стороны от знака "=" будут означать два независимых объекта с одинаковым содержанием. И здесь последующее изменение одной переменной никак не скажется на другой.

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

a = 2; b = a; b = 3

print 'семантика копирования: a=', a, 'b=', b

a=[2,5]; b = a; b[0] = 3

print 'семантика указателей: a=', a, 'b=', b

Результат:

семантика копирования: a= 2 b= 3

семантика указателей: a= [3,5] b= [3,5]

Для тех из вас, кто хочет знать, в чем тут дело, я приведу другой взгляд на присваивание в Python. Если в таких языках как Basic, Pascal, C/C++ мы имели дело с переменными-«емкостями», и хранимыми в них константами (числовыми, символьными, строковыми - не суть важно), а операция присваивания означала «занесение» константы в присваиваемую переменную, то в Python мы уже должны работать с переменными-«именами» и именуемыми ими объектами. (Замечаете некоторую аналогию с языком Prolog?) Что же такое объект в Python? Это все то, чему можно дать имя: числа, строки, списки, словари, экземпляры классов (которые в Object Pascal и называются объектами), сами классы (!), функции, модули и т.д. Так вот, при присваивании переменной некоторого объекта, переменная становится его «именем», причем таких «имен» объект может иметь сколько угодно и все они никак не зависят друг от друга.

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

Так вот, если мы пишем:

a=[2,5]; b = a; b[0] = 3

Python это интерпретирует так:

• дать объекту «список [2,5]» имя a;
• дать этому объекту еще одно имя - b;
• модифицировать нулевой элемент объекта.

Вот и получилась «псевдо» семантика указателей.

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

t = (1, 2, [7,5], 'string')

t[0] = 6 # так нельзя

del t[1] # тоже ошибка

t[2][1] = 0 # допустимо,

# теперь третья компонента - список [7,0]

t[3][0] = 'S' # ошибка: строки не мутируемы

5. Весьма оригинальным является то, как в Python группируются операторы. В Pascal для этого служат операторные скобки begin-end, в C, C++, Java - фигурные скобки {}, в Basic применяются закрывающие окончания конструкций языка (NEXT, WEND, END IF, END SUB).

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

if x > 0:

print ‘ x > 0 ’

x = x - 8

else:

print ‘ x <= 0 ’

x = 0

Тем самым, хороший стиль записи программ, к которому призывают преподаватели языков Pascal, C++, Java и т.д., здесь приобретается с самого начала, поскольку по-другому просто не получится.

4.Описание языка. Управляющие конструкции.

if <условие1>: <оператор1>

[elif <условие2>: <оператор2>]*

[else: <оператор3>]

Оператор «если». Часть в квадратных скобках является необязательной. Следующий за скобками символ «*» означает, что заключенная в скобки часть может быть записана неоднократно одна за другой.

Здесь, при истинности <условия1> будет выполнен <оператор1> и проигнорированы ветки elif и else. В противном случае, если истинно <условие2>, то выполняется <оператор2>, ветка else игнорируется. Иначе выполняется <оператор3>.