Сценарий python что такое

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

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

1. Использование интерактивного режима.
2. Использование режима сценария.

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

Система написания сценариев еще называется этимологическим сценарием. Сначала мы пишем программу Python внутри файла (например, сценария) в режиме скрипта, а затем выполняем файл после его сохранения в нашей системе.

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

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

Мы можем писать длинные фрагменты кода в режиме сценария, и поэтому многие опытные программисты предпочитают его интерактивному режиму выполнения. Файл Python, который мы создаем в данном режиме, обычно сохраняется по умолчанию в папке, в которой установлена наша IDE Python, и сохраняется с расширением файла Python(«.py»).

Запуск программы Python в режиме скрипта

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

Создание и сохранение файла сценария программы Python

Мы должны последовательно выполнить следующие шаги, чтобы создать и сохранить сценарий программы Python на нашем устройстве:

Шаг 1. Откройте текстовый редактор Python или любой другой текстовый редактор по нашему выбору (здесь мы будем использовать редактор файлов Python).

Шаг 2: Напишите в текстовом редакторе следующую программу Python:

 
# Taking two variables from user 
a = int(input("Enter a number of integer value: ")) 
b = int(input("Enter second integer number: ")) 
# Addition of two input variables 
c = a + b 
# Printing addition result in the output 
print("The addition of two numbers given by you is: ", c) 

как мы записали:

Шаг 3: После написания программы Python мы должны сохранить файл внутри папки, в которой установлена наша IDE Python, и мы должны сохранить его с расширением файла Python, то есть с расширением .py. Мы сохранили файл с именем code.py на нашем устройстве для этой программы.

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

Выполнение сценария программы Python

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

1. Выполнение с помощью терминала командной строки.
2. Выполнение с использованием Python IDE.

Давайте узнаем о каждом методе отдельно и выполним файл скрипта.

Метод 1: выполнение сценария Python с помощью терминала командной строки

Мы можем выполнить файл сценария (code.py), используя терминал командной строки нашей системы. Вывод файла также будет отображаться в оболочке терминала. Чтобы выполнить файл сценария Python, мы должны выполнить следующие шаги:

Шаг 1. Откройте терминал командной строки и найдите каталог, в котором установлена Python IDE в нашей системе (там же, где мы сохранили файл сценария Python). Чтобы найти каталог, мы можем использовать путь к каталогу с ‘cd’, как мы это делали:

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

Шаг 2: Теперь мы должны написать имя файла скрипта (с расширением), и добавить python перед именем файла скрипта следующим образом:

Шаг 3: Когда мы нажимаем клавишу ввода, Python начинает выполнение файла сценария в терминале командной строки.

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

Так мы можем выполнить наш файл сценария Python в терминале командной строки нашей системы.

Метод 2: выполнение скрипта Python с использованием Python IDE

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

Шаг 1. Откройте Python IDE и откройте файл сценария в Python IDE, используя заданную опцию открытия.

Шаг 2: Теперь, открыв файл, мы увидим опцию запуска вверху:

Или мы даже можем использовать ярлык кнопки «F5» для запуска файла сценария в Python IDE.

Мы видим, что наш файл сценария (code.py) запускается в среде Python IDE, и как только мы дадим необходимые входные значения, мы сможем увидеть вывод программы внутри оболочки Python, как показано ниже:

Выход:

Enter a number of integer value: 38 
Enter second integer number: 26 
The addition of two numbers given by you is:  64 

Так мы можем запустить или выполнить наш файл сценария Python с помощью Python IDE, установленного в нашей системе.

Преимущества режима скрипта

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

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

Заключение

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

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

Первые шаги

Рассмотрим пример иллюстрирующий математическую модель описывающий
траекторию полета мяча в воздухе. Из второго закона Ньютона,
предполагая незначительное сопротивление воздуха, мы можем вывести
зависимость вертикального положения ( y ) мяча от времени
( t ):
$$
begin{equation*}
tag{1}
y = v_0 t -0.5 g t^2
end{equation*}
$$

где ( v_0 ) — начальная скорость, ( g ) — ускорение
свободного падения, значение которого положим равным ( 9.81 ) м/c ( ^2 ).

Сценарий

Рассмотрим сценарий на Python для вычисления по простой
формуле. Предположим, что сценарий у нас сохранен в виде текста в
файле ball.py

# -*- coding: utf-8 -*-
# Программа для вычисления положения мяча при вертикальном движении

v0 = 5       # Начальная скорость
g = 9.81     # Ускорение свободного падения
t = 0.6      # Время

y = v0*t - 0.5*g*t**2

Разбор сценария

Сценарий на языке Python — это текстовый файл (в нашем случае
ball.py), содержащий некоторые
инструкции. Мы можем читать сценарий и понимать, что программа
способна делать, но сам сценарий не выполняет никаких действий на
компьютере, пока интерпретатор Python не прочитает текст сценария и не
преобразует его в некоторые действия.

Когда сценарий запущен в интерпретаторе Python, он разбирается и выполняется
построчно. Первые две строки

# -*- coding: utf-8 -*-
# Программа для вычисления положения мяча при вертикальном движении

являются комментариями*, т.е. как только встречается символ #,
интерпретатор Python воспринимает оставшуюся часть строки как
комментарий, пропускает ее и переходит к следующей строки.

Следующие 3 строки, интерпретируемые Pyhton:

v0 = 5       # Начальная скорость
g = 9.81     # Ускорение свободного падения
t = 0.6      # Время

В Python выражения вида v0 = 5 известны как операторы
присваивания. Значение правой части, в нашем случае целое число
5, становится объектом, а имя переменной слева *— именованной
ссылкой на этот объект. Всякий раз, когда мы запишем v0, Python
заменит ее целым значением 5. Выражение v1 = v0 создает новое
имя для того же целого объекта со значением 5, а не копирует
объект.

Таким образом, прочитав эти строки интерпретатор Python знает три
переменных v0, g, t и их значения. Эти переменные используются
интерпретатором в следующей строке, фактически реализующей некоторую
формулу

В этой строке Python интерпретирует * как оператор умножения, - *—
вычитания, ** *— возведения в степень (естественно, + и
интерпретируются как операторы сложения и деления соответственно). В
результате вычисляется значение по формуле в правой части выражения,
которое присваивается переменной с именем y. Последняя строка
сценария

выводит на печать значение переменной y. Таким образом при запуске
сценария ball.by на экране будет выведено
число 1.2342. В тексте сценария имеются также и пустые строки, которые
пропускаются интерпретатором Python. Они добавлены для лучшей
читабельности кода.

Запуск сценариев Python

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

Такая команда явно указывает, что в качестве интерпретатора файла
ball.py должен использоваться Python. Также могут задаваться
аргументы командной строки, который загружается сценарием.

Команда python ball.py ... должна запускаться в консольном окне
(терминал в Unix, Командная строка (Command Prompt) в MS Windows).

В случае, когда файлу установлено разрешение на выполнение (команда
chmod a+x ball.py) в ОС Unix (Linux), сценарий можно запускать
командой, сценарий можно запускать командой

В этом случае первая строка сценария должна содержать описание
интерпретатора:

В ОС MS Windows можно писать просто

вместо python ball.py, если расширение .py ассоциировано с
интерпретатором Python.

Программа на Python, использующая библиотечные функции

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

Вычислим рассматриваемый нами угол. Перед тем как написать программу,
мы должны сформулировать некий алгоритм, т.е. некий способ
выполнения необходимых вычислений. В нашем случае, пусть ( x ) —
расстояние от нас до точки подброса мяча, а ( y ) — высота, на
которой находится мяч. Таким образом, образуется угол ( theta ) с
поверхностью земли, где ( mathrm{tg,} theta = y/x ). Следовательно,
( theta=mathrm{arctg,}(y/x) ).

Напишем сценарий выполняющий эти вычисления. Введем переменные x и
y для координат положения ( x ) и ( y ), и переменную
angle для угла ( theta ). Сценарий сохраним в файл
ball_angle.py

# -*- coding: utf-8 -*-

x = 10   # горизонтальное положение
y = 10   # вертикальное положение

angle = atan(y/x)

print (angle/pi)*180

В этом сценарии строка angle = atan(y/x) иллюстрирует
вызов функции atan, соответствующей математической функции
( mathrm{arctg} ), с выражением y/x в качестве аргумента
или входного параметра. Отметим, что тригонометрические функции
(такие как atan) возвращают значение угла в радианах, поэтому для
преобразования результата в градусы мы использовали выражение
(angle/pi)*180.

Теперь, запустив на выполнение сценарий, мы получим ошибку

NameError: name 'atan' is not defined

Очевидно, интерпретатор Python не распознал функцию atan, так как
эта функция еще не импортирована в программу. Достаточно большой
функционал доступен в интерпретаторе по умолчанию, однако намного
больший функционал реализован в библиотеках Python. Для того, чтобы
активировать использование дополнительного функционала, мы должны его
явно импортировать. В Python функция atan, как и множество других
математических функций, собраны в библиотеке math. Такая
библиотека в терминах Python называется модулем. Чтобы мы могли
использовать функцию atan в нашем сценарии, мы должны написать

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

from math import atan, pi

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

Мы будем использовать такое выражение для импорта, чтобы иметь доступ
ко всем общим математическим функциям. Таким образом рабочий сценарий
ball_angle.py имеет вид:

# -*- coding: utf-8 -*-
from math import *

x = 10   # горизонтальное положение
y = 10   # вертикальное положение

angle = atan(y/x)

print (angle/pi)*180

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

Программа на Python с векторизацией и построением графиков

Вернемся к задаче, описывающей вертикальное положение ( y ) мяча после
подбрасывания. Предположим, что нас интересуют значения ( y ) в
каждую миллисекунду первой секунды полета. Это требует повторения
вычисления ( y = v_0 t — 0.5 g t^2 ) тысячу раз.

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

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

# -*- coding: utf-8 -*-

from numpy import linspace
import matplotlib.pyplot as plt

v0 = 5
g = 9.81
t = linspace(0, 1, 1001)

y = v0*t - 0.5*g*t**2

plt.plot(t, y)
plt.xlabel(u't (с)')
plt.ylabel(u'y (м)')
plt.show()

def height(t):
	h =  v0*t - 0.5*g*t**2
	return h

h = lambda t: v0*t - 0.5*g*t**2

Данный сценарий строит график зависимости вертикального положения мяча
от времени (см. рис. :numref:`%s<1st-fig-1>`). Отметим, что строки для
вычисления из сценария ball.py из раздела
Программа на Python с переменными мало изменены, но значение y
вычисляется для тысячи точек.

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

from numpy import *
from matplotlib.pyplot import *

Мы видим, что numpy является модулем Python. Этот модуль содержит
огромный функционал для математических вычислений, а модуль
matplotlib.pyplot реализует возможности для построения двумерных
графиков. Приведенные выше строки представляют быстрый способ загрузки
всего функционала, связанного с вычислениями и построением
графиков. Однако, фактически мы используем только несколько функций в
нашем сценарии: linspace, plot, xlabel и
ylabel. Многие разработчики считают, что мы должны импортировать
только то, что нам нужно, а не весь возможный функционал:

from numpy import linspace
from matplotlib.pyplot import plot, xlabel, ylabel

Другие предлагают способ импорта, когда используется префикс для
функций модуля

import numpy as np
import matplotlib.pyplot as plt

...

t = np.linspace(0, 1, 1001)
   
...

plt.plot(x,y)

Мы будем использовать все три способа. В нашем сценарии мы
использовали два из них.

from numpy import linspace
import matplotlib.pyplot as plt

Рисунок 1: График, построенный с помощью нашего сценария.

Функция linspace принимает три аргумента и, в общем случае,
вызывается следующим образом:

Функция linspace генерирует n равноотстоящих координат,
начинающихся со значения start, и заканчивающихся
stop. Выражение linspace(0, 1, 1001) создает 1001 координату
от 0 до 1 включительно. Математически это означает, что отрезок
( [0,1] ) разбивается на 1000 равных отрезков и значения координат
в этом случае вычисляются следующим образом: ( t_i = i/1000, i = 0, 1,
ldots, 1000 ).

Функция linspace возвращает объект класса array,
т.е. некоторый набор чисел (массив). При выполнении арифметических операций с
такими объектами, на самом деле эти операции осуществляются для каждого
элемента массива. В результате получается аналогичный массив из 1001
элемента, который сохраняется в переменную y. Таким образом y
также является массивом.

Такой подход вычисления нескольких чисел в одну строку называется
векторизацией. Этот способ очень удобен, так как сокращает не только
количество кода, но и время вычислений по сравнению с использованием
циклов for или while.

Команды для построения графиков достаточно просты:

1. plot(x, y) означает построение графика зависимости y от
x

2. xlabel(u't (с)') помещает текст t (с) на оси x.

3. ylabel(u'y (м)') помещает текст y (м) на оси y.

Некоторые основные понятия

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

Интерактивное использование Python

Python можно использовать интерактивно, т.е. мы можем не писать
сначала сценарий и запускать его, выполнять операторы и выражения в
оболочке Python. Мы рекомендуем использовать оболочку IPython (на
наш взгляд — лучшая из альтернативных оболочек Python). При
использовании IDE Spyder, IPython доступен при запуске в правом
нижнем окне. Следуя подсказке IPython In [1]: (подсказка *— это
так называемый знак готовности, т.е. программа предлагает вводить
команды), мы можем выполнять вычисления

In [1]: 2+2
Out[1]: 4	

In [2]: 2*4
Out[2]: 8

In [3]: 10/2
Out[3]: 5

In [4]: 4**4
Out[4]: 256

Ответу интерпретатора IPython предшествует Out [q]:, где q *—
номер соответствующей входной строки.

Заметим, что, как и в сценарии, можно выполнить команду
from math import * для использования, например, pi или
математических функций. Также можно импортировать и другие модули,
когда они понадобятся.

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

In [1]: v0 = 5

In [2]: g = 9.81

In [3]: t = 0.6

In [4]: y = v0*t - 0.5*g*t**2

In [5]: print y
1.2342

Иногда может понадобиться повторить команду, которую уже выполняли
ранее. Для этого можно воспользоваться стрелкой вверх на
клавиатуре. Нажав эту клавишу один получим предыдущую команду, два
раза *— команду перед этой и т.д. С помощью стрелки вниз мы будем
пробегать вперед по истории команд. Также можно поправить выбранную
команду перед ее выполнением.

Арифметические операции, круглые скобки и ошибки округления

Как известно арифметические операции +, -, *, / и
** имеют приоритет выполнения. Python обрабатывает операции слева
направо, вычисляя один операнд (часть выражения между двумя
последовательными + или -). Внутри каждого операнда операция
** выполняется перед * или /. Рассмотрим выражение
x = 2*4**3 + 10*2 - 1.0/4. В нем три операнда, и Python
начинает обрабатывать их слева. В первом операнде 2*4**3
интерпретатор сначала вычислит 4**3, что даст 64, затем
результат умножается на 2. Получаем 128. Следующий операнд
10*2, т.е. 20. Затем два операнда складываются, что дает
148. Результат вычисления последнего операнда равен
0.25. Таким образом значение переменной x становится равным
147.75.

Отметим, что круглые скобки используются для группировки
операндов. Пусть x = 4 получим результат деления числа 1.0 на
x+1. Приведем варианты записи в интерпретаторе Python:

In [1]: 1.0/x+1
Out[1]: 1.25

In [2]: 1.0/(x+1)
Out[2]: 0.2

При первой попытке выполнено сначала деление 1.0 на x, к
которому затем прибавляется 1. Python не воспринимает x+1 как
знаменатель. Во второй попытке мы воспользовались круглыми скобками,
чтобы сгруппировать знаменатель. Так как большинство чисел в памяти
компьютера могут быть представлены только приближенно, иногда может
получаться не точное значение, что обусловлено ошибками округления.

Переменные и объекты

Переменные в Python имеют некоторый тип. Если мы запишем x = 2 в
сценарии Python, то x становится целой переменной, т.е. переменной
типа int (целое число). Аналогично, выражение x = 2.0 означает, что x
переменная типа float (действительное число). В любом случае, Python
воспринимает x как объект типа int или float. Узнать тип
объекта x можно с помощью команды type(x). Еще один основной
тип переменной *— это тип str или строка, используемый для
текстовых объектов. Такие переменные задаются двойными или одинарными
кавычками:

x = "This is the text"
y = 'This is the text'

Оба оператора создают объекты типа str.

При необходимости можно преобразовывать типы. Если, например, x
— объект типа int, с помощью выражения y = float(x) мы
создаем объект с плавающей точкой. Аналогично можно получить целое
число из типа float, воспользовавшись int(x). Преобразование
типов может осуществлятся автоматически, как будет показано чуть ниже.

Договоримся, что имена переменных должны быть информативными. При
вычислении математических величин, которые имеют стандартные символы,
например, ( alpha ), это следует отразить в имени переменной,
используя слово alpha в имени переменной в сценарии. Если,
например, вычисляем число овец (sheep), то одним из подходящих имен
для переменной может быть no_of_sheep. Такие имена переменных
делают более читабельным код программы. Имена переменных могут
содержать цифры и знак подчеркивания, но не могут начинаться с
цифры. Буквы могут быть строчными и прописными, в Python они
отличаются. Отметим, что некоторые имена в Python зарезервированы и мы
не можем их использовать в качестве имен переменных. Вот некоторые
примеры: for, while, else, global, return и
elif. Если мы случайно используем зарезервированное слово в
качестве имени переменных, то получим сообщение об ошибке.

Выражение x = 2 присваивает значение 2 переменной x. Как
можно увеличить x на 4? Мы можем воспользоваться выражением
x = x + 4 или выражением (дающим более быстрые вычисления)
x += 4. Аналогично, x -= 4 уменьшает значение переменной x
на 4, x *= 4 умножает x на 4, x /= 4 делит x на 4,
обновляя значение переменной x.

Что произойдет, если x = 2, т.е. объект типа int, и мы к нему
прибавим 4.0 (объект типа float)? Будет иметь место
автоматическое преобразование типов и новое x примет значение
6.0, т.е. станет объектом типа float.

In [1]: x = 2

In [2]: type(x)
Out[2]: int

In [3]: x = x +4.0

In [4]: x
Out[4]: 6.0

In [5]: type(x)
Out[5]: float

Целочисленное деление

Следует обратить внимание на еще одну проблему — целочисленное
деление*. Рассмотрим пример деления числа 1 на 4:

In [1]: 1/4
Out[1]: 0

In [2]: 1.0/4
Out[2]: 0.25

Представлены два способа выполнения этой операции, при этом второй
вариант дает правильный результат.

В Python версии 2 первый вариант дает результат так называемого
целочисленного деления. В этом случае все десятичные знаки
отбрасываются, т.е. результат округляется до ближайшего меньшего
целого числа. Чтобы избежать этого мы можем явно указать десятичную
точку либо в числителе, либо в знаменателе, либо в обоих
операндах. Если числитель или знаменатель являются переменными,
т.е. мы вычисляем выражение 1/x, то, чтобы получить результат типа
float, можно записать 1/float(x).

В Python версии 3 операция / дает результат типа float, а для
целочисленного деления используется только операция // (//
есть в Python версии 2).

Форматированный вывод текста и чисел

В результате научных вычислений часто на печать выводится текст,
содержащий числа. Естественно желание контролировать формат вывода
числа. Например, мы хотим вывести число 1/3 как 0.33 или в
виде 3.3333e-1 (( 3.3333 times 10^{-1} )). Команда print
— основной инструмент для вывода текста и чисел, обеспечивающий
полное управление форматированием. Первый аргумент команды print
— это строка с определенным синтаксисом, задающим формат вывода, так
называемый printf-синтаксис. Такое название происходит от функции
printf из языка программирования C, где такой синтаксис был введен
впервые.

Предположим, мы имеем действительное число ( 12.39486 ), целое число
( 23 ), и текст «сообщение», которые мы хотим вывести на печать двумя
способами:

real=12.394, integer=23, string=сообщение
real=1.239e+01, integer= 23, string=сообщение

В первом варианте действительное число выведено в десятичной записи 12.394, а
во втором в научной записи (с плавающей точкой) 1.239e+01. Целое
число в первом варианте выведено в компактном виде, а во втором
варианте в текстовом поле из четырех символов.

Следующий сценарий
(formatted_print.py) использует
printf-синтаксис для управления форматированным выводом:

# -*- coding: utf-8 -*-

real = 12.29486
integer = 23
string = 'сообщение'

print "real=%.3f, integer=%d, string=%s" % (real, integer, string)
print "real=%4.3e, integer=%3d, string=%s" % (real, integer, string)

Вывод команды print — это строка, содержащая текст и набор
переменных, вставляемых в текст в местах отмеченных символом
%. После % идет определение формата, например %f (для
действительных чисел), %d (для целых чисел) или %s (для
строк). Формат вида %4.3f означает, что действительное число
выводится в десятичной записи, с тремя знаками после запятой, в поле
из 4 символов. Вариант .3f означает вывод числа в наименьшем
возможном поле, в десятичной записи, с тремя знаками после
запятой. Замена f на e или E приводит к выводу в научном
формате: 1.239e+01 или 1.239E+01. Запись %4d означает
вывод целого числа в текстовом поле из четырех
символов. Действительные числа также могут выводится форматом %g,
который используется для автоматического выбора между десятичным и
научным форматом, дающим более компактную запись (научный формат
удобен для очень маленьких и очень больших чисел).

Типичный пример, когда требуется printf-синтаксис для вывода, когда
нужно напечатать выровненные колонки. Предположим мы хотим напечатать
колонку значений ( t ) и колонку с соответствующими значениями
функции ( f(t) = tsin t ). Простейший вариант

# -*- coding: utf-8 -*-

from math import sin

t = 0
dt = 0.55

t += dt; f = t*sin(t)
print t, f

t += dt; f = t*sin(t)
print t, f

t += dt; f = t*sin(t)
print t, f

дает следующий результат

Terminal> python2 src-python/unformatted_print.py
0.55 0.287477975912
1.1 0.980328096068
1.65 1.64482729695

Обратите внимание на то, что колонки не выровнены, что дает
нечитабельный вывод. Добавив в функцию print следующий аргумент
'%6.2f %8.3f' %(t, f), мы управляем шириной каждой колонки и
количеством знаков после запятой:

0.55    0.287
1.10    0.980
1.65    1.645

print 'При t = {t:g} с, y = {y:.2f} м'.format(t=t, y=y)

print 'При t = %g с, y = %.2f м' % (t, y)

Массивы

В сценарии ball_plot.py из раздела
Программа на Python с векторизацией и построением графиков мы использовали массивы NumPy. Такие
массивы создаются и обрабатываются в соответствии с некоторыми
правилами, при этом управлять массивами можно как целиком, так и
отдельными элементами массива.

Рассмотрим такой пример: предположим у нас есть данные о росте четырех
человек. Эти данные мы можем сохранить в массиве с именем h
следующим образом:

h = zeros(4)
h[0] = 1.60
h[1] = 1.75
h[2] = 1.82
h[3] = 1.72

Здесь элементами массива являются h[0], h[1] и т.д. Самая
первая строка в приведенном фрагменте кода

дает указание Python зарезервировать, или выделить, пространство в
памяти для массива h из четырех элементов с начальными значениями
равными 0. Следующие четыре строки заменяют нулевые значения элементов
массива заданными. Элементы, как правило, индексируются с 0.

Используя двоеточие, мы можем получать срез массива. Например, чтобы
создать новый массив из двух элементов h[1] и h[2], мы можем
использовать следующую конструкцию slice_h = h[1:3]. Отметим, что
определение 1:3 означает индексы 1 и 2, т.е. последний
индекс в определении среза не включается. Полученный массив
slice_h, индексируется стандартно с 0. Доступ к самому последнему элементу
массива можно получить следующим образом h[-1].

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

Построение графиков

Иногда нам нужно построить графики двух функций на одном
рисунке. Предположим у нас есть массив h, заданный выше и массив
H. График с двумя кривыми можно построить следующим образом
(сценарий plotting_two.py):

# -*- coding: utf-8 -*-

import numpy as np
import matplotlib.pyplot as plt

h = np.zeros(4)

h[0] = 1.60; h[1] = 1.75; h[2] = 1.82; h[3] = 1.72
H = np.zeros(4)
H[0] = 0.60; H[1] = 0.30; H[2] = 1.90; H[3] = 1.99

numbers = np.zeros(4)
numbers[0] = 1; numbers[1] = 2; numbers[2] = 3; numbers[3] = 4

plt.plot(numbers, h, numbers, H)
plt.xlabel(u'Номер по порядку')
plt.ylabel(u'Значение')
plt.show()

Результат работы сценария представлен на рисунке

Рисунок 2: График, построенный с помощью сценария.

Две кривые на одном графике можно построить и другим способом,
используя две команды plot. Например, вы можете построить первую
кривую

plot(numbers, h)
hold('on')

Затем можно выполнить различные команды и вычисления в сценарии перед
построением второй кривой

plot(numbers, H)
hold('off')

Мы здесь использовали функцию hold: hold('on') сообщает
Python, чтобы следующие кривые строились в том же окне. Python
выполняет это до тех пор пока не появится команда
hold('off'). Если не использовать команды hold('on') и
hold('off'), то вторая команда построения кривой перепишет первую,
т.е. появится только вторая кривая.

В случае, когда необходимо построить две кривые на отдельных графиках
можно построить стандартно первую кривую

затем выполнить следующие команды

figure()
plot(numbers, H)

Стандартно Python при построении графиков рисует прямые отрезки между
точками со значениями. Можно также организовать другие способы
вывода. Например, команда

построит только точки значений отмеченные символом * (можно
использовать также другие символы).

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

или название графика

Команда

axis([xmin, xmax, ymin, ymax])

задает область построения графика: для оси ( x ) участок от
xmin до xmax, для оси ( y ) участок от
ymin до ymax

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

savefig('pic.png')
savefig('pic.jpg')
savefig('pic.gif')
savefig('pic.eps')
savefig('pic.pdf')

Матрицы

Для линейной алгебры могут понадобится стандартные операции, например,
умножение матрицы на вектор. Для этого можно использовать специальный
тип. Например, мы хотим вычислить вектор ( mathbf{y} ) следующим
образом ( mathbf{y} = mathbf{A}mathbf{x} ), где
( mathbf{A} ) — матрица размера ( 2times 2 ),
( mathbf{x} ) — вектор. Это можно реализовать следующим образом
(сценарий mat_vec_mult.py)

# -*- coding: utf-8 -*-

from numpy import zeros, mat, transpose

x = zeros(2)
x = mat(x)
x = transpose(x)
x[0] = 1.0; x[1] = 3.0

A = zeros((2,2))
A = mat(A)
A[0,0] = 1.0; A[0,1] = 2.0
A[1,0] = 3.0; A[1,1] = 4.0

y = A*x

print y

Здесь сначала x создан как объект типа array, затем тип
переменной x преобразован в тип matrix с помощью команды
mat(x). Далее матрица-строка x преобразована в матрицу столбец
с помощью операции транспонирования transpose(x). Создана матрица
A как массив размерности ( 2times 2 ) командой
zeros((2,2)), преобразована в тип matrix. Затем заданы значения
каждому элементу матрицы. И наконец, умножение матрицы на вектор
выполнено операцией y=A*x. Запуск сценария дает

Входные данные

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

# -*- coding: utf-8 -*-

age = input('Введите Ваш возрастn')
print u'Вы на половине пути к %d' % (age*2)

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

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

name = raw_input('Введите Ваше имя: ')

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

Символьные вычисления

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

x = 2
y = 3
z = x*y
print z

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

from sympy import *
x, y = symbols('x y')
z = x*y
print z

Этот код дает символьный результат x*y. Отметим, что в этом случае
не задаются числовые значения символьным переменным, а используются
только символы.

Выполнение символьных вычислений в Python обеспечивает пакет
SymPy. Каждый символ представлен переменной, но имя символа должно
быть определено либо командой Symbol(имя) для одного символа, либо
командой symbols(имя1 имя2 ...) для нескольких символов. В
сценарии symbolic.py

# -*- coding: utf-8 -*-

from sympy import *

x = Symbol('x')
y = Symbol('y')

print x**2 + 3*y**3
print diff(x**3, x)              # дифференцирование
print integrate(tan(x), x)       # интегрирование
print simplify((x**2+x**3)/x**2) # упрощение выражения
print limit((1+x)**(1/x), x, 0)  # вычисление предела
print solve(x**2-16, x)          # решение уравнения x^2=16

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

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

Можете ли вы ждать, пока разработчики программного обеспечения включат в свою программу нужную вам операцию? А что делать, если ее нужно выполнять чуть иначе для каждого из тысячи объектов? Мы назвали «болевые точки»? Значит, вы готовы к следующему шагу в освоении компьютерного пространства — пора познакомиться с такими понятиями, как сценарий (script).

До недавнего времени сценарные языки не находили широкого распространения при работе на персональных компьютерах. Местом их применения были мощные рабочие станции с операционными системами семейства UNIX. Однако сегодня средний ПК — это суперкомпьютер по меркам недалекого прошлого. Уже не так важно, что сам по себе сценарный язык — интерпретируемый и по сравнению с компилируемыми языками программы на нем исполняются медленнее (есть иная точка зрения [1]). Существенно другое: сценарные языки позволяют кратко и выразительно описать требуемые действия, существенно сократив общее время решения проблемы.

Между сценариями и «настоящими» программами граница очень расплывчатая. Сценарий — это та же программа, но управляющая целыми программными компонентами. Любая достаточно сложная программная система имеет возможности для написания сценариев. Разнятся языки, их гибкость и специализация, но остается главное — возможность программного управления средой.

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

Эти языки часто применяются для системной интеграции, чтобы «склеить» разнородные программные компоненты или среды. Для таких приложений не столь важна скорость выполнения программ на сценарном языке, сколько возможность интеграции (расширения, встраивания) в любые программные системы. Существует немало сценарных языков: Perl, Tcl, Python, PHP, Lua, Rep, Ruby, Pike. Одним из наиболее интересных в этом ряду является язык Python.

Особенности языка Python

История языка Python началась в 1991 г., когда Гвидо ван Россум приступил к работе над ним. Впоследствии он назвал его Python (по словам автора, вовсе не в честь змеи, а в честь шоу на BBC «Monty Python?s Flying Circus»). В основу языка были положены следующие принципы:

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

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

Одним из недостатков языка Python считается невысокое быстродействие написанных на нем программ (однако см. www.bagley.org/~doug/shootout/). Этот недостаток с лихвой компенсируется скоростью разработки программ на Python. Некоторые разработчики замечают, что это единственный язык, на котором они могут писать программы со скоростью мысли, не отвлекаясь на сооружение вспомогательных конструкций, отчасти из-за того, что нет необходимости описывать типы, отчасти благодаря наличию высокоуровневых типов данных, например списка или словаря (хэш, ассоциативный массив).

Задумывался Python и как язык для опытных пользователей-непрограммистов. Этому был посвящен даже проект Computer Programming for Everybody (CP4E, программирование для всех), а сейчас образовательными аспектами Python занимается специальная группа Edu-SIG (Special Interest Group).

Язык Python имеет продуманные средства для объектно-ориентированного программирования. К тому же все элементы, используемые в программе, являются… объектами, включая функции, классы и модули.

Этим языком поддерживается несколько парадигм программирования, в том числе функциональное программирование (ФП). Ярким представителем языков этого направления является Лисп. Конечно, никто не заставляет умещать всю программу в одно выражение, но элементы функционального стиля часто используются в программах на языке Python.

ФП приводит к существенному сокращению объема кода программы и при грамотном подходе к построению алгоритма — к большему быстродействию.

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

На Python создано значительное количество полезного ПО. О больших коммерческих проектах, в которых используется Python, можно узнать на www.python.org/psa/Users.html. На языке Python пишут и ПО для систем реального времени.

Примеры программирования на Python

Для начала рассмотрим что-нибудь несложное, например программу для поиска простых чисел от 1 до N (см. листинг 1).

Листинг 1

import math
N = input("Введите N: ")
if N > 1:
print 2,
for number in xrange(3, N+1, 2):
for divisor in xrange(3, math.sqrt(number)+1, 2):
if number % divisor == 0:
break
else:
print number,

Для N=100 получается ряд:

2 3 5 7 11 13 17 19 23 29 31 37 41
 43 47 53 59 61 67 71 73 79 83 89 97.

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

1. Выделение операторов в блоки осуществляется с помощью отступов.
2. Цикл for работает с последовательностью. Очевидно, что xrange() строит необходимую последовательность.
3. Функция xrange(A, B) — и это проявляется везде в Python — порождает числа от A до B, не включая B. Подобный подход (использование полуоткрытых интервалов) может показаться на первый взгляд странным, но на самом деле он очень логичен при программировании.
4. Функция sqrt (нахождение квадратного корня) берется из стандартной библиотеки.
5. Оператор цикла for (и это сюрприз!) имеет часть else, которая выполняется только в том случае, когда цикл не был прерван по break, а исполнился до конца. В нашем случае именно это и нужно: если делитель не был найден, мы заявляем, что число простое.

А теперь маленький фокус, требующий отдельного пояснения: при создании программы использован интерактивный режим интерпретатора Python (см. листинг 2).

Листинг 2

>>> a = [1, 2, 3]
>>> b = a
>>> a[0] = 0
>>> print b
[0, 2, 3]

Дело в том, что в Python объекты можно связывать с тем или другим именем с помощью оператора присваивания, а убирать эту связь с помощью оператора del. Имя содержит лишь ссылку на объект. Только числа и строки копируются при присваивании, все же остальные объекты получают новые имена.

В следующей программе (см. листинг 3) мы выделим из текста все URL-ссылки и напечатаем полученный список, сгруппированный по хостам.

В этой программе тоже есть особенности:

• Python позволяет вызывать функцию для произведения действий над найденным фрагментом. Мы пользуемся этим для занесения хостов в словарь.
• Используется встроенный высокопроизводительный метод sort().
• Присваивание может производиться сразу для списка значений. Этот прием применен в программе два раза:

  «host, url = ...» и «for
   (host, urls) in ...».

• Основная хитрость заключена в составленном регулярном выражении. Python использует регулярные выражения, которые совместимы с утилитой grep от GNU, выражениями языка Perl и поддерживают Unicode.

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

• Регулярное выражение записано в тройных кавычках. Строки Python можно записывать внутри апострофов, кавычек, тройных кавычек, тройных апострофов. Тройные кавычки (или апострофы) позволяют записывать текст на нескольких строках.
• Наверное, вы обратили внимание на выражение «»*4. Тот же прием пригоден для других последовательностей.

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

Листинг 4

import os, glob, string
print string.join(filter(os.path.isdir,
 glob.glob("*")), "
")

Метод glob() порождает список файлов, удовлетворяющих шаблону «*», т. е. все нескрытые файлы и каталоги. Функция filter() для каждого элемента этого списка вызывает функцию os.path.isdir(), чтобы проверить, является ли указанное имя именем каталога. Наконец, string.join() объединяет все элементы списка в один текст, используя признак конца строки в качестве разделителя.

А вот как выглядит программа (заимствована из справочника FAQ по языку Python), показывающая, как получить список простых чисел, меньших 1000 (см. листинг 5).

Листинг 5

print filter(None,map(lambda
 y:y*reduce(lambda x,y:x*y!=0,map(lambda
 x,y=y:y%x,range(2,pow(y,0.5)
+1)),1),range(2,1000)))

Конечно, это скорее курьез, но игнорировать элементы функционального программирования в Python — значит не использовать очень мощные средства, подчас делающие программы компактнее, понятнее и быстрее. В этом примере применены три коронных приема функционального подхода: map(), reduce() и filter(). Функция map(f, list) порождает новый список, применив к нему f(). Функция filter(f, list) порождает на основе list список, куда входят только те элементы list, которые дают логическое значение «истина» (в языке Python такими являются непустые и ненулевые значения). Наконец, reduce(f, list) позволяет организовать цепочечные вычисления. Например, вычислить факториал от 1000 можно с помощью следующего оператора:

print reduce(lambda x, y: x*y,
 range(1, 1000), 1L)

Заметьте, что для получения этого результата использовались длинные целые. Этот тип данных имеет в Python неограниченную точность, лишь бы хватило памяти для представления числа. (На применение длинных целых указывает буква L у первого элемента цепочки вычислений.)

В языке Python все используемые величины являются объектами, даже функции, классы и модули. Описать собственный класс очень просто. Класс без атрибутов будет аналогом структуры (записи). Соблюдение инкапсуляции объекта лежит на совести программиста: атрибуты являются только открытыми (public), а для акцентирования их приватности (private) имена начинаются с «_» (подчеркивание). Атрибуты, которые начинаются с двойного подчеркивания (но не заканчиваются им!), можно считать аналогом приватных имен, так как доступ к ним затруднен необходимостью указывать имя класса (см. листинг 6).

Листинг 6

————————————————-
class A:
def __init__(self):
self.__secret = 12312
a = A()
# print a.__secret #
 вызывает ошибку, а вот:
print a._A__secret # позволит
 обратиться к __secret

Все методы в языке Python являются виртуальными. Более того, атрибуты можно динамически заменять, добавлять и удалять в уже созданном экземпляре класса. Python поддерживает множественное наследование. Полиморфизм не является отдельным свойством, передаваемым «по наследству»: любой класс, предоставляющий те же методы, что и некоторый другой, будет с ним совместим «по типу» (не вообще, а для определенных операций). Такой подход называют сигнатурным полиморфизмом (signature-based polymorphism). Он позволяет создавать, например, файлоподобный объект, который можно применять везде, где допустимо использовать обычный файловый объект, так как в классе описаны все нужные методы (read, write, close…).

В языке Python также есть средства для переопределения операций. Все встроенные операции можно переопределить, описав методы со специальными именами.

Еще одной особенностью Python является то, что в нем не считается зазорным обращаться напрямую к атрибутам (разумеется, только к тем, о которых договорились, что они открыты для доступа), поэтому текст не засоряется всевозможными get_x/set_x. Это может показаться кощунством с точки зрения канонов ООП. Однако то, что выглядит как обращение к атрибуту, на самом деле может быть работой специального метода, который перехватывает обращения к атрибутам… В силу того что классы тоже являются объектами, есть возможность организации метаклассов, но это уже высший пилотаж объектно-ориентированного программирования.

В примере объектно-ориентированного программирования на Python (см. листинг 7) мы описываем класс Set, моделирующий множество из некоторых элементов. Наверное, нетрудно догадаться, что данный класс имеет несколько методов, в том числе для задания операций, начинающихся и оканчивающихся двойным подчеркиванием «__», а также конструктор __init__ и один атрибут «_dict», который, собственно, и хранит элементы множества. Этот атрибут является словарем — встроенным типом языка Python, по-другому его можно назвать ассоциативным массивом или хэшем. Мы используем именно этот тип данных, так как ключи в словаре всегда уникальные. (Вместо значений используется 1, так как нам важно лишь присутствие или отсутствие ключа, а не его значение.)

Метод __len__() — специальный метод, который вызывается теми, кому нужна длина объекта, скажем, при вызове встроенной функции len(obj). Наверное, вам уже понятно, что __add__() служит для задания бинарной операции «+» над объектом класса Set. Кроме функции __add__ есть еще и __radd__, которая вызывается, если объект стоит справа, а не слева от операции, и «левый» объект не имеет операции __add__. Это позволяет складывать множества и списки, получая в результате множества. Методы __str__ и __repr__ представляют объект в виде строки, например, в операторе print или при явном преобразовании по str(obj) или repr(obj).

Каждый из методов имеет первым аргументом сам объект. По традиции он называется self.

Деструкторы в Python требуются очень редко — только для освобождения каких-либо внешних ресурсов. Объект исчезает, когда исчезает последняя ссылка на него, т. е. del obj удаляет не объект, а всего лишь одну ссылку (конечно, это могла быть последняя ссылка).

Знакомство с языком Python будет неполным, если не привести пример создания пользовательского интерфейса (см. листинг 8). Для этого в Python имеется большой выбор различных инструментов. Используя модуль Tkinter (из стандартной поставки Python), напишем программу, которая будет работать на любой платформе одинаково.

Реализация игры достаточно тривиальна: на сетке (grid) размещаются кнопки, которые, за исключением одной, являются фишками. Атрибут _cells содержит словарь, позволяющий находить объект-кнопку по координате и, наоборот, находить координаты и имя на кнопке по объекту-кнопке. Атрибут _empty_place содержит координаты пустой клетки. С каждой кнопкой связано действие _move_to_empty, выполняемое при наступлении события Button-1 (нажатие левой кнопки мыши). Атрибуты _rows и _cols содержат размеры игрового поля, которое в классическом варианте составляет 4Ё4 (в заголовке определения метода __init__используются значения по умолчанию). Наверное, этого достаточно, чтобы понять логику работы класса Fifteen.

Что касается классов, взятых из модуля Tkinter, то тут тоже все достаточно просто. Обратите внимание, что если у функций или методов много различных аргументов, подавляющее большинство из которых имеют значения по умолчанию, в Python принято применять аргументы с ключевыми словами (именованные аргументы). Такой подход делает программы более наглядными и уменьшает количество ошибок.

В приведенной программе использован метод упаковки grid (). Он удобен во многих случаях. Однако Tkinter предлагает еще два метода: place() и pack(). Первый позволяет располагать объекты в произвольном месте фрейма, а второй — «паковать» объекты с определенными видами привязки друг к другу.

Кстати, вы, вероятно, догадались, что Tkinter — это интерфейс к Tk из Tcl/Tk. В качестве упражнения попробуйте в приведенном листинге найти еще одну полезную мелочь, отличающую Python от других языков программирования. Подсказка: эта мелочь находится в методе Shuffle().

Заключение

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

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

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

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

Об авторе

Сузи Роман Арвиевич — инженер-программист, e-mail: rnd@onego.ru.

Литература

1. Прехельт Л. Эмпирическое сравнение семи языков программирования // Открытые системы. 2000. № 12, www.osp.ru/os/2000/12/045.htm.
2. John K. Ousterhout Scripting: Higher Level Programming for the 21st Century //www.scriptics.com/people/ john.ousterhout/scripting.html.
3. Бройтман О. Драматическая история Python и Zope: Цикл лекций // Софтерра, 2001, www.softerra.ru/review/oses/linux/ 10454/index.html?from=rsp.

Критерии выбора сценарного языка

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

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

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

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

Пользовательская база. Хорошим показателем объема пользовательской базы является активность в группах новостей и списках рассылки. Косвенным признаком может служить число ссылок, выдаваемых поисковыми серверами при введении имени языка, дополненного, например, словом «programming».

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

Язык Perl

Наверное, это самый известный сценарный язык, пользующийся заслуженной популярностью у системных администраторов и Web-мастеров. Perl был создан Ларри Уоллом в конце 1980-х годов (версия 1.0 вышла в свет в 1987 г.). Название Perl происходит от сокращения Practical Extraction and Report Language («практический язык извлечения данных и формирования отчетов»), что достаточно точно отражает его назначение: просмотр и обработка текстовых файлов с извлечением информации и построением отчетов на основе полученных данных. Истории языка Perl посвящен целый сайт http://history.perl.org , где его эволюция дана в контексте других достижений программной индустрии.

В ОС UNIX язык Perl пришел на смену таким инструментам, как sed, awk и sh в задачах, которые, с одной стороны, не совсем тривиальны, а с другой, недостаточно «серьезны», чтобы применять Cи. Сейчас Perl используется за пределами UNIX и не только для обработки текстов. Самое активное применение Perl наблюдается в написании CGI-сценариев для Web-среды. Более того, сама аббревиатура CGI у многих прямо ассоциируется с Perl!

На Perl написано бесчисленное количество модулей, многие из которых свободно доступны через сеть CPAN (Comprehensive Perl Archive Network, своего рода «полное собрание сочинений» для Perl). Но основная сила языка и среды не в количестве и номенклатуре написанного для них ПО. Среда Perl поставляется бесплатно. И это подчас отпугивает некоторых людей, по-видимому полагающих, что хорошее ПО может быть только коммерческим. Они не учитывают, что разработка и особенно поддержка популярного бесплатного продукта может быть поставлена (как в случае Perl), пожалуй, даже лучше многих платных продуктов. Вокруг Perl сложилось довольно значительное сообщество пользователей и разработчиков, пронизанное духом сотрудничества и бескорыстной взаимопомощи. Вы всегда найдете поддержку в списках рассылки, телеконференциях, IRC-каналах, WikiWikiWeb и других местах, посвященных среде Perl.

О самом языке Perl можно сказать, что он очень разнообразен в своих синтаксических проявлениях. Основное кредо Perl: любую задачу можно решить разными путями. По этой причине он, возможно, не самый подходящий язык для начинающих. Язык Perl хорош при создании небольших программ и сценариев с интенсивной обработкой текстов. Секрет мощи Perl в его доступности и в наличии развитого аппарата регулярных выражений. Несмотря на то что язык Perl реализован в виде интерпретатора, на задачах обработки текста он, как правило, работает лишь раза в два медленнее кода на Cи [1]. А если учесть, что при этом код может быть в несколько десятков раз короче, преимущество в скорости создания программ и использовании Perl для таких задач становится очевидным.

Язык Tcl

Говоря о сценарных языках, невозможно обойти стороной язык Tcl (Tool Command Language, «язык команд для инструментария»; произносится «тикль»). Его часто называют Tcl/Tk, дабы подчеркнуть тесную связь с инструментарием Tk, предназначенным для построения графического интерфейса. Создатель языка Джон Устераут (ныне работающий в компании Interwoven) занялся разработкой Tcl с целью получить хороший интерпретируемый язык, который можно было бы встраивать в другие программы для управления ими [2]. До этого каждое программное средство предлагало свой командный язык, часто очень невысокого качества. От Tcl не требовалось слишком многого — минимум переменных, операторов для организации потока управления, функций для работы со строками и т.п. Инструментарий Tk стал следующим детищем автора и задумывался как средство для организации графического интерфейса (столь модного направления в 1990-х годах). Стоит пояснить, что автор поначалу занимался средой Tcl/Tk прежде всего для решения задач своей лаборатории.

Программное обеспечение для поддержки научных разработок обычно строится на основе ядра, которое занимается собственно расчетами (это так называемый back-end), а уже к этому ядру по мере необходимости пристыковываются необходимые интерфейсы оболочки (т. е. front-end). Впрочем, подобный подход используется не только в научном программном обеспечении, но и в разных видах коммерческого и бесплатного ПО. Так, в частности, программа mpg123 для проигрывания MPEG-файлов имеет лаконичный интерфейс командной строки. Однако вы легко можете найти несколько десятков оболочек, разработанных как для текстового (а-ля Turbo Vision или Norton Commander), так и для графического интерфейса. Разумеется, часть этих оболочек выполнена на Tcl/Tk.

Именно для подобных вещей (высокоуровневого управления приложением снаружи или изнутри) Tcl применяется и по сей день, а Tk является одним из стандартов программирования графического интерфейса. В отличие от многих других он остается переносимым и одинаково успешно работает на старых Macintosh и современных UNIX-станциях. Существует объектно-ориентированная разновидность Tcl — incr Tcl (прямая аналогия с Cи++; incr обозначает инкрементирование). Историю Tcl можно найти на http://tcl.activestate.com/doc/tclHistory.html.

Свободно распространяемые продукты для Python

Zope [3] — сервер Web-приложений (аналог сервера Cold Fusion фирмы Allaire), позволяющий создавать и наполнять сайт с активно меняющимся содержимым не только профессиональным программистам, но и редакторам.

www.zope.org, http://zope.net.ru.

Numeric — расширение Python, обеспечивающее численные методы. Имеет очень развитые и эффективные средства манипуляции многомерными массивами. Кроме того, эмулирует базовые возможности MatLab. Находка для тех, кто занимается матричными вычислениями.

http://sourceforge.net/projects/numpy/

Scientific — еще одно «научное» расширение Python. Набор модулей, предоставляющих различные сервисы: геометрические объекты (векторы, тензоры и т.п.), статистические процедуры, перевод единиц измерений, визуализацию (в том числе с использованием VRML) и др.

http://starship.python.net/crew/hinsen/scientific.html

4Suite — набор фирмы Fourththought для работы со спецификациями XML, XPath, XSLT, DOM, RDF, ODS.

www.4suite.com

PyXML — пакет для работы с XML, схожий по функциям с 4Suite. Во второй версии появился интерпретатор встроенной поддержки Unicode, что делает Python идеальным средством для работы с XML. Включает SAX, DOM, интерфейс к синтаксическому анализатору Expat и т.п.

http://sourceforge.net/projects/pyxml/

Python Imaging Library (PIL) — пакет для обработки изображений фирмы Secret Labs AB. Позволяет загружать и редактировать изображения в различных (растровых) форматах.

www.pythonware.com/pil/

Sketch — векторный графический редактор, написанный почти целиком на Python (критичные части выполнены на Cи). Кроме функций собственно редактора предоставляет среду для работы с векторной графикой, в которой сценарные функции принадлежат Python. Только для UNIX.

http://sketch.sourceforge.net

Grail — браузер, написанный на Python. Не претендует на конкуренцию с коммерческими браузерами, а является скорее доказательством того, что на Python можно легко писать и такие приложения.

http://grail.sourceforge.net

Pyne — почтовый клиент и обработчик новостей, написанный на Python. Только для UNIX.

www.yikesstation.freeserve.co.uk/pyne/

Mailman — ПО для организации списков рассылки. Имеет все необходимое для шлюзования с группами новостей, формирования дайджестов, ведения архивов и т.п.

www.list.org

Alice — интерактивная трехмерная графическая среда, создана в университете Карнеги-Меллон. Только для Windows.

http://alice.cs.cmu.edu

ILU — среда унификации языков, совместимая со спецификацией CORBA; создана в исследовательском центре Xerox PARC.

Jython — реализация Python, обеспечивающая компиляцию в байт-коды виртуальной Java-машины. Для тех, кто хочет использовать Python в Java-среде. По мнению пользователей, более удобен при написании графического интерфейса, чем Swing/AWT фирмы Sun Microsystems. Очень хорошо интегрирован с Java (поддерживает прозрачное использование Java-пакетов).

www.jython.org

Полезные ссылки

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

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

Командные оболочки

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

Управляющий язык

Другие пользователи под названием «язык сценариев» понимают «связующий» слой, который используется для управления другими прикладными компонентами (то есть для описания сценария работы). Программы на языке Python действительно нередко используются в составе крупных приложений. Например, при проверке аппаратных устройств программы на языке Python могут вызывать компоненты, осуществляющие низкоуровневый доступ к устройствам. Точно так же программы могут запускать программ- ный код на языке Python для поддержки настройки программного продукта у конечного пользователя, что ликвидирует необходимость поставлять и пересобирать полный объем исходных текстов.

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

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

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

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

Итак, является ли Python языком сценариев? Ответ зависит от того, к кому обращен вопрос. Вообще термин «создание сценариев», вероятно, лучше использовать для описания быстрого и гибкого способа разработки, который поддерживается языком Python, а не для описания прикладной области программирования. По материалам сайта bigindustry.ru

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

Например, мы спрашиваем у пользователя, где он живет. Он вводит: «Москва». Затем спрашиваем, в каком районе – он отвечает «Сокольники» и т.д. Затем эти ответы используются для дальнейшей работы программы. Например, программа выдает номер почтового отделения, которое обслуживает дом, где живет пользователь.

Для начала немного вводных данных.

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

import codecs, sys
outf = codecs.getwriter('cp866')(sys.stdout, errors='replace')
sys.stdout = outf

Сам запрос программы для вовлечения пользователя пишется так: raw_input() Эту команду надо зазубрить!

Практический пример

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

Вариант 1.

Создаем на рабочем столе файл test11.py Не забываем про кодировку файла. Пишем в него руками следующий программный код:

 
# -*- coding: utf- 8 -*-

# Загружаем кодеки для возможности ввода/вывода кириллических символов
import codecs, sys
outf = codecs.getwriter('cp866')(sys.stdout, errors='replace')
sys.stdout = outf

print u"Сколько игроков в команде?",
igroki = raw_input()
print u"Сколько команд участвует в финале?",
komandy = raw_input()
print u"Сколько запасных игроков в каждой команде?",
zapas = raw_input()

print u"На финал приедет %s команд. В каждой команде по %s основных и по %s запасных игроков." % (komandy, igroki, zapas) 

Теперь открываем программу PowerShell и прописываем команду python desktop/test11.py
У вас должно получиться следующее:

Вариант 2.

Создаем файл test12.py Пишем в него следующий программный код:

# -*- coding: utf- 8 -*-

# Загружаем кодеки для возможности ввода/вывода кириллических символов
import codecs, sys
outf = codecs.getwriter('cp866')(sys.stdout, errors='replace')
sys.stdout = outf

igroki = raw_input(u"Сколько игроков в команде? ")
komandy = raw_input(u"Сколько команд участвует в финале? ")
zapas = raw_input(u"Сколько запасных игроков в каждой команде? ")

print u"На финал приедет %s команд. В каждой команде по %s основных и по %s запасных игроков." % (komandy, igroki, zapas) 

 

Теперь открываем программу PowerShell и прописываем команду python desktop/test12.py
У вас должно получиться следующее:

Как мы видим, программа каждый раз останавливается и спрашивает нас и ждет, когда мы введем то или иное число. И только после нашего нажатия на Enter программа продолжает работать.

Домашнее задание

Напишите программный код по аналогии с моим, вводя другой сценарий. Попробуйте также 2 варианта – сначала один, потом второй.

Более сложный вариант интерактивной программы на Питоне (с использованием переменной argv) — здесь. 

А в следующем уроке мы познакомимся с таким понятием, как модули в Python 2.7 — перейти в урок 17. 

В интерпретируемых языках от написания кода до запуска — всего один шаг. Ничего не нужно компилировать в машинный код.

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

Если на каком-то языке удобно писать скрипты, его называют «скриптовым языком» или «языком для написания сценариев».

Скрипты на Python

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

# file <script.py>
print('Hello, world!')
print('This is a python-script!')

Затем мы просто вызываем интерпретатор с полученным файлом на входе:

python3 script.py

Hello, world!
This is a python-script!

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

Скрипты и shebang

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

Интерпретатор указывается специальной строкой в самой первой строчке файла скрипта, которая называется shebang. Это название произошло от первых двух символов такой строчки: # называется sharp, а ! — bang.

Типичный shebang выглядит так:

#!/usr/bin/python3

После символов #! идет путь до интерпретатора. При запуске скрипта с shebang командная оболочка читает первую строку и пробует запустить указанный интерпретатор. Если скрипту с указанным shebang дать права на исполнение, то интерпретатор в командной строке можно не указывать:

cat script.py

#!/usr/bin/python3
print('Hello!')

chmod +x script.py

./script.py

Hello!

Shebang и разные версии Python

В целом shebang — штука довольно простая, когда интерпретатор в системе ровно один. Но мы с вами знаем, что версий Python в системе может быть установлено несколько. Более того, в виртуальном окружении путь к интерпретатору будет отличаться от /usr/bin и будет разным в разных окружениях.

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

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

А теперь рассмотрим правильный способ указывать shebang в проектах на python:

#!/usr/bin/env python3
print('Hello!')

Внимание! авторам, имеющих авторское право на тот или иной текст бренд или логотип, для того чтобы ваша авторская информация свободно не распространялась в ресурсах интернета вы должны ее удалить с таких ресурсов как vk.com ok.ru dzen.ru mail.ru telegram.org instagram.com facebook.com twitter.com youtube.com и т.д в ином случаи размещая информацию на данных ресурсах вы согласились с тем что переданная вами информация будет свободно распространятся в любых ресурсах интернета. Все тексты которые находятся на данном сайте являются неотъемлемым техническим механизмом данного сайта, и защищены внутренним алфавитным ключом шифрования, за любое вредоносное посягательство на данный ресурс мы можем привлечь вас не только к административному но и к уголовному наказанию.

Согласно статье 273 УК РФ