На уроке объясняется синтаксис составления процедуры и функции Питон. Рассматривается вызов функции, параметры функции и процедуры
Содержание:
- Функции в роли процедуры
- Процедура с параметрами
- Локальные и глобальные переменные
- Язык Python функции
Функции в роли процедуры
return).Рассмотрим синтаксис функции-процедуры на примере:
Пример: Создать процедуру для вывода сообщения об ошибке. Запрашивать у пользователя ввести положительное число, в случае ввода отрицательного числа, вызывать процедуру для вывода сообщения об ошибке.
✍ Решение:
def Err(): # определение процедуры print ( "Ошибка: неверные данные" ) n = int ( input('введите положительное число') ) if n < 0: Err() # вызов процедуры
- Процедура — вспомогательный алгоритм, выполняющий некоторые действия.
- Это поименованный фрагмент программы, который можно вызвать.
- Процедура должна быть определена к моменту её вызова. Определение процедуры начинается со служебного слова def.
- Вызов процедуры осуществляется по ее имени, за которым следуют круглые скобки, например, Err().
- В одной программе может быть сколько угодно много вызовов одной и той же процедуры.
- Использование процедур сокращает код и повышает удобочитаемость.
Процедура с параметрами
Как используются в Python параметры процедуры, рассмотрим на примере.
Пример: Написать процедуру, которая печатает 60 раз указанный символ (введенный с клавиатуры), каждый с новой строки.
✍ Решение:
1 2 3 4 5 |
def printChar(s): for i in range(60): print (s) sim = input('введите символ') printChar(sim) |
- Глобальная переменная — если ей присвоено значение в основной программе (вне процедуры).
- Локальная переменная (внутренняя) известна только на уровне процедуры, обратиться к ней из основной программы и из других процедур нельзя.
- Параметры процедуры — локальные переменные. В программе s — локальная переменная.
Задание Python 3_0:
Создать процедуру, которая вычисляет разность двух вводимых пользователем числа. Выполнить задание двумя способами: 1) процедура без параметров: числа — глобальные переменные, определенные в основной программе; 2) процедура с параметрами: числа — параметры процедуры.
Локальные и глобальные переменные
Примеры использования локальных и глобальных переменных:
1 2 3 4 |
x = 3 # глобальная переменная def pr(): # процедура без параметров print (x) # вывод значения глобальной переменной pr() |
1 2 3 4 5 |
x = 3 # глобальная переменная def pr(a): # процедура с параметром a = 4 # локальная переменная print (a) # 4 pr(x) # передача параметра глобальной переменной (3) |
1 2 3 4 5 6 |
x = 3 # глобальная переменная def pr(): # процедура без параметров global x x = 1 print (x) # вывод измененного значения глобальной переменной (1) pr(x) |
Задание Python 3_1:
Напишите процедуру, которая выводит на экран в столбик все цифры переданного ей числа, начиная с последней:
число: 4673 результат: 3 7 6 4
Задание Python 3_2:
Напишите процедуру, которая выводит на экран все делители переданного ей числа (в одну строчку).
Задание Python 3_3:
Составить программу с процедурой для вычисления степени числа (входные параметры: число и степень).
Рекомендации: для вычисления степени числа можно использовать функцию pow(число, степень)
Задание Python 3_4:
Напишите процедуру, которая принимает параметр – натуральное число N – и выводит первые N чисел Фибоначчи.
Пример использования ключевого слова global:
Поменять значений двух переменных.
✍ Решение:
-
Решение 1:
def Swap(): global x,y t = x x = y y = t x=3 y=5 Swap() print(x,y)
Решение 2:
def Swap(): global x,y (x, y) = (y, x) (x,y)=(3,5) Swap() print(x,y)
Задание Python 3_5:
Создайте процедуру без параметров AddLeftDigit(), которая добавляет введенную цифру K (0<=K<=9) слева к введенной цифре D (0<=D<=9) и выводит результат. Используйте ключевое слово global для работы с глобальными переменными.
Ожидаемый результат:
введите D (0<=D<=9) и K(0<=K<=9): >>>2 >>>4 результат: 42
Часть функций языка Python являются встроенными функциями, которые обеспечены синтаксисом самого языка. Например, int, input, randint.
Рассмотрим пример создания пользовательских функций.
- Функция — это поименованный фрагмент программы, который можно вызвать.
- Как и процедура, функция должна быть определена к моменту её вызова (служебное слово def).
- Функция в отличии от процедуры возвращает значение.
- Для возврата значения функции используется оператор return.
- Вызов функции осуществляется по ее имени и обычно сопровождается выводом значения.
Пример:
Найти максимальное значение из значений двух переменных.
✍ Решение:
def max(a,b): if(a>b): return a else: return b x=int(input()) y=int(input()) print('max = ',max(x,y))
Задание Python 3_6:
Создайте функцию для поиска минимума среди трех чисел (три параметра функции).
Пример:
Вычислить сумму цифр числа.
1 2 3 4 5 6 7 8 |
def sumD(n): # определение функции с параметром sum = 0 while n!= 0: sum += n % 10 n = n // 10 return sum # возврат значения функции # основная программа print (sumD(1075)) # вызов функции с параметром |
Задание Python 3_7:
Напишите функцию, которая вычисляет количество цифр числа.
Задание Python 3_8:
Создайте функцию, которая вычисляет сумму всех чисел от 1 до N. N — параметр функции.
Задание Python 3_9:
Напишите функцию, которая вычисляет факториал натурального числа N.
Исключения и взаимодействие с API
На текущий момент мы уже знаем достаточно многое из основ ООП. Однако созда-ние приложений под Windows в среде Delphi не ограничивается применением объ-ектно-ориентированного подхода. В частности, иногда возникают такие ситуации, что приходится обращаться к функциям Windows API напрямую. Кроме того, нам следует рассмотреть обработку ошибок в программах, а так же осветить вопрос некоторых глобальных объектов.
Исключения и их классы
Исключительные ситуации, или исключения (exception) могут возникать по ходу выполнения программы ввиду целого ряда причин. Они могут быть вызваны как ошибками в коде программы (например, при попытке обратиться к объекту, который не был предварительно создан), при вводе пользователем неожидаемых значений (например, строки, которая не может быть приведена к числу), при ошибках работы оборудования и т.д. Любая программа, претендующая на качественную разработку, должна уметь обрабатывать все подобные исключительные ситуации.
При возникновении подобных ошибок в программах, созданных при помощи Delphi, автоматически создается объект — Exception. Класс Exception является базовым для ряда других классов исключений — EMathError, EInvalidOp, EZeroDivide и т.д. (названия всех классов, относящиеся к исключениям, принято начинать не с буквы T, а с буквы E). Он происходит непосредственно от класса TObject и имеет 2 свойства — Message и HelpContext, а так же 8 методов.
Свойство Message имеет тип string и содержит описание исключения. При возникновении ошибки этот текст используется в окне сообщения. Ас войство HelpContext определяет индекс раздела справочного файла, содержащего информацию об ошибке. Если значение этого свойства равно нулю, то оно будет ссылаться на раздел справки родительского объекта.
Что касается методов, то все они представлены различными вариантами метода Create. Сам метод Create для исключений определен следующим образом:
constructor Create(const Msg: string);
Т.е., фактически, создавая исключение, следует сразу же назначить значение его свойству Message при помощи аргумента конструктора. Другой вариант конструктора, CreateHelp, позволяет параллельно назначить значение и для второго свойства:
constructor CreateHelp(const Msg: string; AHelpContext: Integer);
Если в тексте сообщения следует привести какие-либо динамически получаемые данные, то используют вариант конструктора с суффиксом Fmt:
constructor CreateFmt(const Msg: string; const Args: array of const);
constructor CreateFmtHelp (const Msg: string; const Args: array of const; AHelpContext: Integer);
При этом значения, указанные в массиве Args, будут подставлены в строку. Для этого используется функция Format, которой передаются строка и массив в качестве аргументов. Эта функция выполняет подстановку значений массива в места строки, выделенные при помощи символа %. Например, если строка выглядит как «Ошибка в функции %s», а массив определен как «[‘MyFunc’]», то результатом выполнения этой функции будет «Ошибка в функции MyFunc». Соответственно, создание подобного исключения будет выглядеть следующим образом:
constructor CreateFmt('Ошибка в функции %s', ['MyFunc']);
Как уже было отмечено, класс Exception имеет ряд потомков, каждый из которых предназначен для обработки того или иного типа ошибок. Например, для математических ошибок определен класс EMathError. Однако этот класс сам по себе не используется, зато его потомки, среди которых отметим классы EInvalidOp, EOverflow, EZeroDivide, используются для оповещения о таких ситуациях, как неверная операция, переполнение буфера и попытка деления на 0, соответственно.
При возникновении исключительной ситуации создается исключение того или иного вида, на основании чего можно определить, в чем именно кроется проблема.
Вызвать исключение в программе можно и искусственным методом — при помощи ключевого слова raise. Например программа может проверять какой-либо ввод пользователя, и в том случае, если он оказывается не тем, что ожидалось, генерировать исключительную ситуацию:
if password <> 'password' then raise Exception.Create('Неверный пароль!');
Выполнение оператора, указанного после raise, приводит к возникновению исключительной ситуации. После этого дальнейшее выполнение кода процедуры прерывается, равно как и кода, вызвавшего эту процедуру, если вызов был произведен из другой подпрограммы. Перемещение исключения можно рассматривать с точки зрения всплытия, т.е. с места своего возникновения ошибка последовательно «всплывает» сначала к вызвавшей данную процедуру или функцию подпрограмме, от нее — к следующей и т.д., пока не дойдет до уровня выполнения программы, т.е. до глобального объекта Application. На этом, конечном этапе и будет выдано сообщение об ошибке.
ПРИМЕЧАНИЕ
С некоторыми глобальными объектами, в том числе с Application, мы ознакомимся несколько позже в этой же главе.
Если при этом ошибка возникла в основном коде программы (т.е. вызвавший ошибку код был написан в самом файле проекта dpr), то на этом выполнение программы прекратится, о чем будет выдано сообщение (рис. 10.1).
Рис. 10.1. Ошибка приложения
В том же случае, если исключительная ситуация произошла в каком-либо модуле, то программа продолжит свою работу, ожидая дальнейших действий пользователя. Однако некоторые данные при этом могут оказаться утерянными (например, функция не вернет значения), или же может оказаться невыполненным какой-либо иной важный код, скажем, создающий глобальные объекты, сохраняющий информацию и т.д. Все это говорит о том, что исключительные ситуации следует обрабатывать.
Обработка исключений
Для обработки исключительных ситуаций в Delphi используются специальные операторы — try…except и try…finally. Эти операторы являются своего рода ловушками для исключительных ситуаций и позволяют разработчику приложения предусмотреть код, обрабатывающий возникшие исключения. Тем самым можно на любом этапе перехватить дальнейшее всплытие ошибки.
При помощи оператора try…except выполняет перехват ошибки, как правило, с целью ее подавления. Он имеет следующий синтаксис:
try
<потенциально вызывающий исключения код>
except
[ on <Класс исключения> do <оператор>; ]
end;
В том случае, если между except и end не писать никакого кода, то исключительная ситуация будет просто подавлена. Однако такое подавление чаще всего не является достаточным условием, поскольку оно не несет никакой информации ни пользователю, ни самой программе. Например, если так подавить ошибку с неверным паролем (а из-за подавления никакого сообщения выдано не будет), то пользователь такой программы может лишь догадываться, почему после того, как он сообщил пароль, ничего не происходит. В данном случае было бы правильным все-таки сообщить о том, что пароль введен не верно. Для этого используют вложенную секцию on…do:
try
if password <> 'password' then raise Exception.Create('Неверный пароль!');
except
on E: Exception do ShowMessage(E.Message);
end;
На сей раз в случае возникновения исключения пользователь получит уведомление о том, что же произошло. Для этого мы создали объект E, которому автоматически присваивается значение ошибки, и использовали его для вывода информации о ней. Дальнейшее выполнение программы в данном случае будет продолжено, поскольку после окончания блока try…end исключение более не существует.
На самом деле, использование такого объекта может быть необязательным, если детальная информация об ошибке не представляется необходимой. В таком случае можно использовать следующий блок обработки исключения:
try
if password <> 'password' then raise Exception.Create('Неверный пароль!');
except
on Exception do ShowMessage('ОШИБКА!');
end;
Что касается блоков обработки, то их может быть несколько, каждый — для своего класса исключения:
try
a:=b*c/d;
except
on EZeroDivide do ShowMessage('Делить на 0 нельзя');
on EOverflow do ShowMessage('Слишком большое число');
on EMathError do ShowMessage('Математическая ошибка');;
end;
Здесь мы определили 3 блока, и в случае возникновения той или иной исключительной ситуации, будет выдано то или иное сообщение. Этим данная часть оператора напоминает оператор case, для которого, как мы помним, существовал вариант «для остальных случаев» — else. Имеется такая возможность и здесь:
try
a:=b*c/d;
except
on EZeroDivide do ShowMessage('Делить на 0 нельзя');
on EOverflow do ShowMessage('Слишком большое число');
on EMathError do ShowMessage('Математическая ошибка');
else
ShowMessage('Общая ошибка');
end;
Наконец, если тип ошибки не имеет никакого значения, то можно оставить только общий обработчик, для чего не требуется даже ключевого слова else:
try
a:=b*c/d;
except
ShowMessage('Общая ошибка');
end;
Важно лишь отметить, что все эти блоки выполняются только тогда, когда возникает исключительная ситуация. При этом, если после ключевого слова try расположено несколько операторов, и исключение возникает в одном из них, то все последующие выполнены не будут. Вместе с тем, случаются ситуации, когда имеется код, который следует выполнить в любом случае, без оглядки на то, что случится перед этим. В таких случаях используют другой оператор - try…finally, и требующий обязательного выполнения код помещают в часть после finally. Типичным примером использования такой конструкции можно считать уничтожение объектов или иные операции освобождения памяти, а так же закрытия файлов и т.д. Например, при работе с файлами всегда следует использовать try…finally для закрытия файла:
try
Rewrite(F);
writeln(F,s);
finally
CloseFile(F);
end;
В данном случае, если даже произойдет ошибка, связанная с доступом к файлу — т.е. если его не удастся открыть (например, если диск защищен от записи), или же записать в него информацию (нет места на диске), закрыт он будет в любом случае, что предотвратит возможные дальнейшие ошибки. При этом само исключение подавлено не будет, т.е. сообщение об ошибке будет выведено и дальнейшее выполнение подпрограммы (но уже после блока finally…end) будет прервано.
Но оба подхода можно комбинировать. Например, в данном случае блок try…finally можно вложить в блок try…except:
try
AssignFile(F);
try
Rewrite(F);
writeln(F,s);
finally
CloseFile(F);
end;
except
on E: Exception do ShowMessage(E.Message);
end;
Кроме этого, в Delphi допускается вкладывать однотипные обработчики ошибок друг в друга, например, один блок try…except может быть вложен в другой.
Глобальные объекты
При создании Windows-приложений нередко возникает необходимость в управлении программой в целом как отдельным объектом. Для этих целей в Delphi предусмотрен специальный объект — Application класса TApplication, представляющий программу в целом. Его использование можно увидеть в любом файле проекта VCL-приложения. Чтобы увидеть это, достаточно создать новое приложение и открыть файл проекта, для откытия которого можно воспользоваться списком модулей, вызываемого кнопкой View Unit (можно так же через главное меню — View ‘ Units, или при помощи сочетания горячих клавиш Ctrl+F12). По умолчанию он имеет название Project1, и его стандартный код имеет вид, приведенный в листинге 10.1.
Листинг 10.1. Заготовка кода для VCL-приложения
program Project1;
uses
Forms,
Unit1 in 'Unit1.pas' {Form1};
{$R *.res}
begin
Application.Initialize;
Application.CreateForm(TForm1, Form1);
Application.Run;
end.
Уже по приведенному в листинге коду мы можем познакомиться с 3 основными методами этого объекта — Initialize, CreateForm и Run. Первый производит подготовительную работу, т.е. фактически, создает объект приложения. Метод CreateForm используется для создания окон приложения, а метод Run производит фактический запуск программы на выполнение. Среди других методов приложения моно отметить такие, как Minimize и Restore, служащие, соответственно, для сворачивания программы на панель задач и для ее восстановления, а так же метод BringToFront, который выводит окно на верхнюю поверхность рабочего стола. Метод Terminate используется для прекращения работы программы (он вызывается автоматически, когда закрывается главное окно приложения). Еще 4 метода — HelpCommand, HelpContext, HelpJump и HelpKeyword — предназначены для работы со справочными файлами.
При работе приложения, в случае обработки больших массивов данных, возникают случаи, когда программа не только не реагирует на действия пользователя, но даже не может выполнить обновление собственного окна. Для того, чтобы предотвратить подобные ситуации, используют специальный метод — ProcessMessages, который предписывает приложению обработать накопившуюся очередь сообщений.
Среди свойств приложения, прежде всего, следует отметить такие, как Title, Icon и HelpFile. Свойство Title определяет заголовок программы, т.е. то, что вы видите на панели задач. Свойство Icon определяет значок («иконку») программы. Ну а свойство HelpFile связывает приложение с файлом справочной информации. Все эти свойства можно определить как программно, написав соответствующий код, так и при помощи окна свойств проекта (Project > Options), на закладке Application (рис. 10.2).
Рис. 10.2. Установка параметров приложения в окне свойств проекта
Если установить в диалоге Project Options новые значения и нажать на кнопку OK, то внесенные изменения для свойств Title и HelpFile отобразятся в коде программы. Что касается значка программы, то он хранится в отдельном файле ресурсов (res), который присоединяется к приложению в процессе компиляции, для чего используется директива «{$R *.res}».
Поскольку любой визуальный компонент может отображать всплывающую текстовую подсказку, то для объекта Application предусмотрен ряд свойств, управляющих видом и выводом таких подсказок. В частности, цвет определяют при помощи свойства HintColor, задержку перед появлением после наведения на компонент мышки — при помощи HintPause, а время его отображения — свойством HintHidePause.
Некоторые свойства приложения доступны только во время выполнения. Среди них можно выделить свойство ExeName, содержащее информацию об имени самого исполняемого файла, включая полный путь к нему.
Помимо Application, при запуске приложения создается еще один глобальный объект, представляющий экранную среду — Screen. При помощи этого объекта можно получить информацию о разрешение экрана, установить вид курсора мыши для приложения, или узнать количество его окон. Основные свойства класса TScreen приведены в таблице 10.1.
Таблица 10.1. Основные свойства TScreen
| Свойство | Тип | Описание |
|---|---|---|
| ActiveControl | TWinControl | Указывает, какой элемент управления в данный момент имеет фокус ввода |
| ActiveForm | TForm | Указывает, какое окно активно в данный момент |
| Cursor | TCursor | Определяет вид указателя курсора мышки для приложения |
| Cursors | array of HCursor | Список всех курсоров, доступных для приложения |
| Fonts | TStrings | Список названий всех шрифтов, доступных для вывода на экран |
| FormCount | Integer | Указывает на число окон (форм), созданных приложением |
| Forms | array of TForm | Список всех окон, созданных приложением |
| Height | Integer | Указывает на вертикальное разрешение экрана |
| HintFont | TFont | Определяет шрифт для всплывающих подсказок |
| IconFont | TFont | Определяет шрифт для подписей к значкам в диалогах выбора файлов |
| MenuFont | TFont | Определяет шрифт для меню |
| Width | Integer | Указывает на горизонтальное разрешение экрана |
| WorkAreaHeight | Integer | Указывает на высоту рабочего стола Windows |
| WorkAreaLeft | Integer | Указывает на координаты левого угла рабочего стола |
| WorkAreaRect | Integer | Указывает на координаты прямоугольника, образующего рабочий стол |
| WorkAreaTop | Integer | Указывает на координаты верхнего угла рабочего стола |
| WorkAreaWidth | Integer | Указывает на ширину рабочего стола |
Использовать объекты Screen и Application можно как в главном модуле программы (файле проекта), так и в модулях отдельных форм. При использовании в главном мо-дуле обычно устанавливают глобальные параметры, например, вид всплывающих подсказок. В частности, можно определить довольно-таки экзотический вид всплы-вающих подсказок, дополнив программу следующими строками:
Screen.HintFont.Color:=$00408080; // цвет шрифта
Screen.HintFont.Size:=14; // размер шрифта
Application.HintColor:=$0080FF80; // цвет фона
Application.HintPause:=1000; // задержка перед появлением 1 секунда
Application.HintHidePause:=2000; // время показа 2 секунды
Если вставить этот код в dpr-файл перед обращением к методу Application.Run, то можно будет убедиться, что через секунду после наведения курсора на окно запу-щенного приложения будет появляться всплывающая подсказка с крупным коричне-вым текстом на зеленом фоне. Разумеется, при этом для окна приложения следует установить значения свойства ShowHint в true, и написать какой-либо текст для свой-ства Hint. Впрочем, это можно сделать не только через инспектор объекта в процессе разработки приложения, но и программно, поместив соответствующий код после создания формы. В результате мы получим код, приведенный в листинге 10.2.
Листинг 10.2. Использование объектов Application и Screen
program app_scr;
uses
Forms,
Unit1 in 'Unit1.pas' {Form1};
{$R *.res}
begin
Application.Initialize;
Application.CreateForm(TForm1, Form1);
Form1.Hint:='Ну и подсказочка!';
Form1.ShowHint:=true;
Screen.HintFont.Color:=$00408080;
Screen.HintFont.Size:=14;
Application.HintColor:=$0080FF80;
Application.HintPause:=1000;
Application.HintHidePause:=2000;
Application.Run;
end.
Здесь же можно установить и такие параметры, как заголовок программы, используя свойство Title объекта Application:
Application.Title:='Super Hint!';
Кроме того, можно поэкспериментировать с такими свойствами объекта Screen, как Height и WorkAreaHeight, причем для вывода информации можно использовать заго-ловок главного окна:
Form1.Caption:='Экран '+IntToStr(Screen.Height)+', рабочий стол '+ IntToStr(Screen.WorkAreaHeight);
В данном случае в строку Uses потребуется дописать модуль SysUtils, поскольку ис-пользованная здесь функция IntToStr расположена именно в этом модуле. Оконча-тельный вариант программы можно найти в каталоге DemoPart2Global.
Работа с INI-файлами
При разработке приложений часто встает вопрос о том, где и как хранить информа-цию, связанную с его настройками. Нередко для этих целей используются специаль-ные INI-файлы, которые хранят в себе информацию, разбитую по логическим груп-пам в виде «ключ-значение». В Delphi имеется класс, обеспечивающий простую ра-боту с такими файлами — TIniFile. Чтобы приложение могло получить доступ к этому классу, в секцию используемых модулей следует добавить inifiles.
Имя файла, ассоциированного с объектом типа TIniFile, задается непосредственно при создании экземпляра этого класса, в конструкторе Create:
var MyIni: TIniFile;
...
TIniFile.Create('myfile.ini');
Впоследствии можно узнать, какой файл ассоциирован с данным объектом при по-мощи его свойства FileName, однако изменить его уже не получится. Вместе с тем, у TIniFile имеется свыше 20 методов, при помощи которых можно считывать, прове-рять и изменять содержимое INI-файла. Все они приведены в таблице 10.2.
Таблица 10.2. Методы класса TIniFile
| Метод | Принимаемые параметры | Описание |
|---|---|---|
| DeleteKey | const Section, Ident: String | Удаляет указанный ключ из INI файла |
| EraseSection | const Section: String | Удаляет содержимое указанной секции в INI файле |
| ReadSection | const Section: String; Strings: TStrings | Считывает имена всех ключей в указанной секции и заносит их в список строк |
| ReadSections | Strings: TStrings | Считывает названия всех секций в файле и заносит их в список строк |
| ReadSectionValues | const Section: String; Strings: TStrings | Считывает все значения в указанной секции и заносит их в список строк |
| ReadString | const Section, Ident, Default: String | Считывает и возвращает значение-строку из указанного ключа |
| WriteString | const Section, Ident, Value: String | Записывает значение-строку в указанный ключ |
| ReadBool | const Section, Ident: String; Default: Boolean | Считывает и возвращает булево значение из указанного ключа |
| ReadDate | const Section, Ident: String; Default: TDateTime | Считывает и возвращает значение-дату из указанного ключа |
| ReadDateTime | const Section, Ident: String; Default: TDateTime | Считывает и возвращает значение-дату и время из указанного ключа |
| ReadFloat | const Section, Ident: String; Default: Double | Считывает и возвращает значение-вещественное число из указанного ключа |
| ReadInteger | const Section, Ident: String; Default: Longint | Считывает и возвращает значение-целое число из указанного ключа |
| ReadTime | const Section, Ident: String; Default: TDateTime | Считывает и возвращает значение-время из указанного ключа |
| SectionExists | const Section: String | Проверяет INI файл на наличие указанной секции |
| WriteBool | const Section, Ident: String; Value: Boolean | Записывает булево значение в указанный ключ |
| WriteDate | const Section, Ident: String; Value: TDateTime | Записывает значение-дату в указанный ключ |
| WriteDateTime | const Section, Ident: String; Value: TDateTime | Записывает значение-дату и время в указанный ключ |
| WriteFloat | const Section, Ident: String; Value: Double | Записывает значение-вещественное число в указанный ключ |
| WriteInteger | const Section, Ident: String; Value: Longint | Записывает значение-целое в указанный ключ |
| WriteTime | const Section, Ident: String; Value: TDateTime | Записывает значение-время в указанный ключ |
| ValueExists | const Section, Ident: String | Проверяет INI файл на наличие указанного ключа в определенной секции |
Таким образом, можно без каких-либо дополнительных накладных расходов (с точки зрения написания собственного кода), создавать и считывать стандартные INI-файлы. Например, мы можем создать приложение, которое сможет «запоминать» введенную информацию и отображать ее при следующем запуске. В принципе, мы уже делали нечто подобное еще при создании программы «угадывания чисел», рассмотренной в первой части. Однако тогда мы лишь последовательно записывали в файл пару строк, а затем таким же образом их считывали. Но если бы нам требовалось сохранить большее количество значений, то мы столкнулись бы с трудностями такого рода, как невозможность идентифицировать то или иное значение при просмотре файла. Кроме того, пришлось бы постоянно держать в уме, какая по строка что должна хранить. Использование INI-файлов решает эту задачу.
Для примера возьмем консольное приложение, которое будет последовательно спрашивать различную информацию у пользователя, а затем сохранит ее в указанном файле. При следующем запуске она сможет считать этот файл и вывести информацию из него на экран. Основное тело программы при этом может получиться примерно таким, как показано в листинге 10.3.
Листинг 10.3. Название листинга
program myini;
{$APPTYPE CONSOLE}
uses
SysUtils, IniFiles;
var
ans: Char;
fn: string;
begin
write('Load data from an INI file? [Y/N]');
readln(ans);
if (ans='Y') or (ans='y') then begin
write('Please input file name: ');
readln(fn);
fn:='c:'+fn+'.ini';
if FileExists(fn) then begin
ShowData(fn);
end else begin
writeln('File not found and will be created.');
FillData(fn);
end;
end else begin
write('Please input file name to save data: ');
readln(fn);
fn:='c:'+fn+'.ini';
FillData(fn);
end;
readln(fn);
end.
Прежде всего, наша программа интересуется, хочет ли пользователь просмотреть информацию из уже существующего файла, или нет, и если хочет, то запрашивает имя файла. Здесь мы подразумеваем, что пользователь будет вводить только имя файла, без пути и расширения, которые добавляются автоматически. Затем стандартная функция FileExists проверяет получившийся файл на существование, после чего либо выводит его содержимое при помощи процедуры ShowDate (которую нам еще предстоит создать), либо выводит сообщение о том, что файл не найден, но будет создан. После этого программа обращается к процедуре FillData, которая так же будет нами написана для ввода информации и сохранения ее в INI-файле. Эта же функция будет вызвана и в том случае, если пользователь изначально откажется от вывода информации, в таком случае программа предварительно запросит имя файла для дальнейшего сохранения.
Теперь, когда основа программы готова, можно определиться, какие данные мы хотим хранить, и какой для этого понадобится формат файла. Допустим, мы хотим сохранить информацию 2-х категорий: персональную и рабочую. В таком случае наш INI файл будет состоять из 2 секций, скажем, Userdata и Jobdata. В первой секции сохраним имя (Name) и возраст (Age), а во второй — должность (Title) и оклад (Salary). Процедура, отвечающая за вывод информации, получится достаточно простой — в ней достаточно создать INI-файл с указанным именем и последовательно считывать информацию, попутно выводя ее на экран. Например, для строкового значения мы получим следующий код:
writeln('Name...... '+IniF.ReadString('Userdata','Name','Anonymous'));
Если же речь идет о числовом значении, то нам придется предварительно преобразовать его в строку:
writeln('Age....... '+IntToStr(IniF.ReadInteger('Userdata','Age',0)));
Несколько сложнее получится код процедуры для записи файла, что, впрочем, связано не с самой записью данных, а в том, что их предварительно следует получить от пользователя. Поэтому там, где мы при выводе обходились одной строкой кода, для ввода понадобится целых 3, а так же переменная для хранения вводимого значения:
write('Name: ');
readln(s);
IniF.WriteString('Userdata','Name',s);
Подобный код потребуется выполнить для каждого поля данных, при этом нам понадобятся 3 различных переменных для хранения данных 3 типов (дважды — строк, и по разу целое и вещественное числа). Предварительно следует не забыть создать переменную типа TIniFile, и вывести пояснительный текст, а к завершению работы процедуры освободить память, занимаемую более не нужной переменной. Последнее условие следует выполнить и в процедуре ShowData. В итоге мы получим код, приведенный в листинге 10.4.
Листинг 10.4. Процедуры сохранения и считывания INI-файлов
procedure FillData(fn: string);
var
IniF: TIniFile;
s: string;
i: integer;
f: double;
begin
IniF:=TIniFile.Create(fn);
writeln('Please fill a form...');
write('Name: ');
readln(s);
IniF.WriteString('Userdata','Name',s);
write('Age: ');
readln(i);
IniF.WriteInteger('Userdata','Age',i);
write('Position: ');
readln(s);
IniF.WriteString('Jobdata','Title',s);
write('Salary: ');
readln(f);
IniF.WriteFloat('Jobdata','Salary',f);
IniF.Free;
end;
procedure ShowData(fn: string);
var
IniF: TIniFile;
begin
IniF:=TIniFile.Create(fn);
writeln('Name...... '+IniF.ReadString('Userdata','Name','Anonymous'));
writeln('Age....... '+IntToStr(IniF.ReadInteger('Userdata','Age',0)));
writeln('Position.. '+IniF.ReadString('Jobdata','Title','Unemployed'));
writeln('Salary.... '+FloatToStrF(IniF.ReadFloat('Jobdata','Salary',0.00),ffFixed,6,2));
IniF.Free;
end;
С полным исходным кодом программы можно ознакомиться в примере, расположенном в каталоге DemoPart2IniFiles.
Работа с реестром Windows
Файлы INI и класс TIniFiles — достаточно удобный способ хранения различной настроечной информации. Тем не менее, начиная с Windows 95, появилось централизованное хранилище для настроек системы и всех установленных программ — реестр (Registry). При разработке приложений в Delphi удобнее всего работать с реестром, используя класс TRegistry. Чтобы включить объявление этого класса, следует указать модуль registry в списке uses.
Реестр Windows имеет несколько ключевых разделов, в чем можно убедиться, открыв имеющуюся в Windows программу редактирования реестра (regedit). В частности это разделы HKEY_CLASSES_ROOT, HKEY_CURRENT_USER, HKEY_USERS, HKEY_LOCAL_MACHINE и HKEY_CURRENT_CONFIG. Чтобы приступить к работе с реестром из программы, требуется указать один из разделов. Делается это при помощи свойства RootKey:
var Reg: TRegistry;
...
Reg:=TRegistry.Create;
Reg.RootKey:=HKEY_CURRENT_USER;
Далее в ход идут методы класса TRegistry. В частности, за выбор раздела реестра, из которого надо будет считывать данные, используется метод OpenKeyReadOnly. В качестве аргумента ему передается адрес раздела реестра, например:
Reg.OpenKeyReadOnly('SOFTWAREMySoftTestApp');
Если указанный раздел существует, и к нему может быть обеспечен доступ, то обращение к данному методу вернет истину. Если же раздела может не существовать, или если требуется открыть раздел на запись, то используют метод OpenKey:
Reg.OpenKey('SOFTWAREMySoftTestApp',true);
Для него в качестве 2-го параметра указывают булево значение, которое указывает на то, должен ли указанный раздел быть создан, если его не существует. В результате выполнения приведенного кода раздел, при необходимости, будет создан и открыть на чтение и запись. Если же требуется только создать новый раздел, то используют метод CreateKey:
Reg.CreateKey('SOFTWAREMySoftTestApp');
Для удаления раздела используют метод DeleteKey, а для проверки указанного раздела на существование — KeyExists. Подобно методу CreateKey, эти методы так же принимают адрес раздела и возвращают ложь или истину в зависимости от результата операции.
Если же требуется выполнить проверку на наличие значения в текущем открытом разделе, то используют метод ValueExists, которому в качестве аргумента передают имя значения.
Что касается записи и считывания значений, то, подобно классу TIniFile, для TRegistry определен ряд методов для взаимодействия с данными различных типов, причем для реестра к типам Boolean, String, Double, Integer и даты-времени, добавляется еще и Currency. Соответственно, мы имеем 8 пар методов для этих целей.
Для примера рассмотрим приложение, состоящее из единственного окна, которое будет «запоминать» свои размеры и расположение на экране. Для этого создадим новое VCL-приложение (File ‘ New ‘ Application), щелкнем сначала по его форме (Form1), а затем — по окну инспектора объекта (Object Inspector). В нем выберем закладку Events (события), найдем событие OnClose и дважды щелкнем по строке напротив. В результате мы получим заготовку для процедуры TForm1.FormClose, в которую нам надо будет добавить объявление переменной для реестра:
var
Reg: TRegistry;
Затем в теле функции напишем следующие строки:
Reg:=TRegistry.Create;
Reg.RootKey:=HKEY_CURRENT_USER;
Reg.OpenKey('SOFTWAREMySoftTestApp',true);
Reg.WriteInteger('left',Form1.Left);
Reg.WriteInteger('top',Form1.Top);
Reg.WriteInteger('height',Form1.Height);
Reg.WriteInteger('width',Form1.Width);
Reg.Free;
Вначале мы создаем экземпляр класса, затем выбираем корневой раздел, после чего открываем ключ на запись (он будет создан при необходимости), и последовательно заносим в него пространственные координаты окна. В завершение работы этой процедуры мы экземпляр класса удаляется из памяти за ненадобностью.
Теперь рассмотрим считывание из реестра, для чего создадим процедуру, обрабатывающую событие создания окна, для чего в инспекторе объекта найдем событие OnCreate и сделаем двойной щелчок напротив него. В получившейся процедуре нам так же понадобится сначала объявить переменную Reg, затем создать экземпляр класса и установить корневой раздел. Затем следует открыть раздел на чтение, причем если это окажется невозможным (а при первом запуске так и будет, поскольку раздел будет создан только после выхода из программы), то считывать ничего не потребуется. Поэтому задействуем условный оператор:
if Reg.OpenKeyReadOnly('SOFTWAREMySoftTestApp') then begin
...
end;
После этого остается считать все нужные данные из реестра, присваивая хранящиеся в них значения соответствующим свойствам Form1. Например, для высоты и ширины мы получим:
Form1.Height:=Reg.ReadInteger('height');
Form1.Width:=Reg.ReadInteger('width');
Вместе с тем, было бы полезным все-таки проверять наличие запрашиваемых значений в реестре, чтобы избежать возникновения исключительных ситуаций. Для этого всякий раз надо будет проверять ключ на существование:
if Reg.ValueExists('width') then Form1.Width:=Reg.ReadInteger('width');
В результате код этого модуля программы получит приблизительно такой вид, как показано в листинге 10.5.
Листинг 10.5. Сохранение координат и размеров окна в реестре
unit Unit1;
interface
uses
Windows, Forms, Registry;
type
TForm1 = class(TForm)
procedure FormCreate(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
procedure TForm1.FormCreate(Sender: TObject);
var
Reg: TRegistry;
begin
Reg:=TRegistry.Create;
Reg.RootKey:=HKEY_CURRENT_USER;
if Reg.OpenKeyReadOnly('SOFTWAREMySoftTestApp') then begin
if Reg.ValueExists('left') then
Form1.Left:=Reg.ReadInteger('left');
if Reg.ValueExists('top') then
Form1.Top:=Reg.ReadInteger('top');
if Reg.ValueExists('height') then
Form1.Height:=Reg.ReadInteger('height');
if Reg.ValueExists('width') then
Form1.Width:=Reg.ReadInteger('width');
end;
Reg.Free;
end;
procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
var
Reg: TRegistry;
begin
Reg:=TRegistry.Create;
Reg.RootKey:=HKEY_CURRENT_USER;
Reg.OpenKey('SOFTWAREMySoftTestApp',true);
Reg.WriteInteger('left',Form1.Left);
Reg.WriteInteger('top',Form1.Top);
Reg.WriteInteger('height',Form1.Height);
Reg.WriteInteger('width',Form1.Width);
Reg.Free;
end;
end.
С исходным кодом приложения так же можно ознакомится, посмотрев его в каталоге DemoPart2Registry.
Процедуры и функции стандартных диалогов
В Delphi предусмотрено несколько процедур и функций, предназначенных для вывода простых диалоговых окон. В частности, процедура ShowMessage и функция MessageDlg позволяют вывести сообщение, а функции InputBox и InputQuery отображают окно для ввода информации.
Простейшим вариантом вывода сообщения является использование процедуры ShowMessage. Она отображает переданную ей в качестве аргумента строку на простом диалоговом окне с единственной кнопкой OK. Типичный пример использования этой процедуры — информирование пользователя о выполнении той или иной части программы:
ShowMessage('Формат диска C: завершен');
Кроме самой процедуры ShowMessage, имеются 2 других варианта — ShowMessagePos и ShowMessageFmt. Первый позволяет вывести диалоговое окно в определенном месте, что достигается путем указания координат по горизонтали и вертикали:
ShowMessagePos('Формат диска C: завершен',100,200);
Второй позволяет вывести отформатированную строку, используя обращение к функции Format, как и в случае с конструктором исключений. Таким образом, для вывода сообщения с переменной частью предпочтительно использовать именно этот вариант процедуры:
ShowMessageFmt('Формат диска %s завершен',['C:']);
Все варианты процедуры ShowMessage выводят окно с единственной кнопкой OK, при этом, разумеется, никакого значения не возвращается. В том же случае, если сообщение выводится для того, чтобы запросить у пользователя подтверждения на то или иное действие, то нам, во-первых, потребуется функция — чтобы получить вариант ответа, а так же возможность указать возможные варианты. Все это мы имеем в лице функции MessageDlg, которая имеет следующее определение:
function MessageDlg(const Msg: string; DlgType: TMsgDlgType; Buttons: TMsgDlgButtons; HelpCtx: Longint): Word;
Здесь сразу же требуется прояснить 2 момента: тип диалога и тип кнопок. За тип диалога отвкечает 2-й параметр, который имеет тип TMsgDlgType и может принимать одно из следующих значений:
- mtWarning — диалог типа «предупреждение», имеет заголовок «Warning» и рисунок, изображающий восклицательный знак на фоне желтого треугольника;
- mtError — диалог типа «ошибка», имеет заголовок «Error» и изображение косого креста в красном круге;
- mtInformation — диалог типа «информация», имеет заголовок «Information» и значок со стилизованной буквой «i» в синих тонах;
- mtConfirmation — диалог типа «подтверждение», имеет заголовок «Confirm» и рисунок с зеленым вопросительным знаком;
- mtCustom — диалог произвольного типа, имеет заголовок, соответствующий имени выполняемого файла и не содержит изображения.
ПРИМЕЧАНИЕ
Внешний вид изображений, символизирующих диалог того или иного типа, периодически претерпевает некоторые изменения, в зависимости от версии Delphi.
Следующий параметр, имеющий перечисляемый тип TMsgDlgButtons, позволяет указать, какие кнопки должны быть расположены на диалоговом окне. Всего предусмотрено 11 вариантов кнопок, среди них предусмотрены такие, как OK, Cancel, Yes, No и т.д. При этом каждая такая кнопка (кроме Help), будучи нажатой пользователем, закрывает окно, а функция возвращает значение, соответствующее нажатой кнопке. Все варианты кнопок и возвращаемые ими значения, приведены в таблице 10.3.
Таблица 10.3. Варианты кнопок и значения, возвращаемые при их нажатии
| Значение | Описание | Возвращаемый результат |
|---|---|---|
| mbYes | Кнопка с надписью «Yes» (да) | mrYes |
| mbNo | Кнопка с надписью «No» (нет) | mrNo |
| mbOK | Кнопка с надписью «OK» | mrOk |
| mbCancel | Кнопка с надписью «Cancel» (отмена) | mrCancel |
| mbAbort | Кнопка с надписью «Abort» (прервать) | mrAbort |
| mbRetry | Кнопка с надписью «Retry» (повторить) | mrRetry |
| mbIgnore | Кнопка с надписью «Ignore» (игнорировать) | meIgnore |
| mbAll | Кнопка с надписью «All» (все) | mrAll |
| mbNoToAll | Кнопка с надписью «No to All» (нет для всех) | mrNoToAll |
| mbYesToAll | Кнопка с надписью «Yes to All» (да для всех) | mrYesToAll |
| mbHelp | Кнопка с надписью «Help» (справка) | — |
Следует оговориться, что все возвращаемые значения, на самом деле, являются целыми числами, что видно по определению функции. Но поскольку запомнить, что, к примеру, возвращаемое значение для OK — это 1, а для Yes — 6, весьма проблематично, то на практике вместо них используются константы, которые как раз и были приведены в таблице 10.3.
Что касается вариантов использования этой функции, то оно сводится к тому, что пользователю выводится какое-либо сообщение, предусматривающее возможность того или иного ответного действия:
MessageDlg('Ошибка чтения с диска. Продолжить?', mtError, [mbRetry, mbAbort], 0);
Поскольку эта функция возвращает то или иное значение, то ее использование часто сопровождается условным оператором:
if MessageDlg('Форматировать диск C:?',mtConfirmation,[mbYes,mbNo],0) = mrYes then FormatDriveCProc();
Другой вариант, для случая с множественными вариантами ответа — использование совместно с оператором-переключателем:
case MessageDlg('Файл изменен. Сохранить перед выходом?', mtWarning, [mbYes, mbNo, mbCancel], 0) of
mrYes: begin SaveFileProc(); Close; end;
mrNo: Close;
mrCancel: exit;
end;
Подобно процедуре ShowMessage, для функции MessageDlg так же предусмотрен вариант с позиционированным выводом окна. Такой вариант этой функции называется MessageDlgPos. Ее отличие от MessageDlg состоит в том, что к списку аргументов добавлено еще 2 параметра, отвечающих за расположение окна. Такой вариант используется, например, при поиске с заменой в текстовых редакторах:
MessageDlgPos('Заменить это вхождение?', mtConfirmation, [mbYes, mbNo], 0, X, Y);
Все рассмотренные нами подпрограммы применяются для вывода сообщений. Что касается ввода, то для этих целей, как уже отмечалось, используют функции InputBox и InputQuery. Обе они выводят окно, позволяющее пользователю ввести какое-либо значение — число или строку. Различие между ними состоит лишь в том, что InputBox возвращает непосредственно результат (в виде строки), а InputQuery — истину или ложь, в зависимости от того, нажмет пользователь OK или Cancel. При этом само значение возвращается в качестве одного из параметров. В итоге мы имеем следующий синтаксис для этих функций:
function InputBox(const ACaption, APrompt, ADefault: string): string;
function InputQuery(const ACaption, APrompt: string; var Value: string): Boolean;
Таким образом, какую из функций лучше использовать в данный момент, зависит от контекста применения. Например, если надо просто получить какое-либо значение от пользователя, то можно использовать функцию InputBox:
UserName := InputBox('Запрос','Введите ваше имя','анонимно');
В данном случае последний параметр функции будет использован в качестве значения по умолчанию (рис. 10.3).
Рис. 10.3. Диалоговое окно функции InputBox
Если же в зависимости от того, введет или нет пользователь новое значение, должна быть выполнена та или иная ветвь алгоритма, то предпочтительнее использовать функцию InputQurey:
if InputQurey('Курс доллара ','Введите новый курс',NewCur) then UpdatePrc();
Помимо приведенных здесь процедур и функций, в VCL имеется ряд иных подпрограмм, использующих диалоговые окна, включая такие, как диалог выбора каталога или файла. Но поскольку их использование сопряжено с некоторыми неудобствами, в частности, им приходится передавать большое число параметров, то на практике для тех же целей чаще используют компоненты. Например, функция PromptForFileName используется для вывода диалога сохранения или открытия файла. Но более типичным (и удобным!) вариантом обращения к таким диалогам является использование таких стандартных компонент VCL, как TOpenDialog и TSaveDialog, с которыми мы познакомимся в следующей части этой книги.
Обработка сообщений и Windows API
Как ни широк охват VCL, иногда все-таки возникает потребность в обращении к функциям Windows напрямую. Например, для того же самого вывода окна с текстовым сообщением можно использовать собственную функцию Windows API — MessageBox:
MessageBox(0, 'Текст сообщения', 'Заголовок', MB_OK);
Необходимость использования функций Windows API может быть вызвана, например, соображениями компактности исполняемого файла: использование диалогов Delphi автоматически подразумевает использование целого рада модулей, необходимых для оконного интерфейса. Если же в самой программе такие модули (например, forms) не задействуются, то их включение в исполняемый код только ради диалога не является хорошей идеей.
В то же время, обращение к функциям Windows API может быть вызвано, например, необходимостью перехвата непредусмотренных в Delphi сообщений.
ПРИМЕЧАНИЕ
Еще одной темой, важной для дальнейшего изучения программирования в Windows вообще и в среде Delphi в частности, является концепция событийного программирования. Дело в том, что хотя ОС Windows, в отличие от Delphi, и не является объектной средой, подход к организации взаимодействия приложений (как с пользователем, так и с системой), основан на одном и том же, а именно — на событиях.
Как мы уже знаем, для событий в VCL используются обработчики событий. Но важно знать, что каждое событие порождает сообщение. Таким образом, отслеживая поступающие сообщения и отсылая собственные, мы можем действовать в обход ограничений VCL.
Для отправки сообщений чаще всего используют функции SendMessage и PostMessage. Обе они выполняют отправку сообщения конкретному окну, разница заключается лишь в том, что SendMessage ожидает ответа от получившего сообщение обработчика, а PostMessage возвращает ответ немедленно. Ценность этих функций состоит в том, что в отличие от средств, предоставляемых VCL, они могут взаимодействовать не только в рамках одного приложения, но и между совершенно разными программами и даже устройствами.
Хотя детальное ознакомления с работой Windows API явно не вписывается в рамки данной книги (не забываем, что Delphi была создана как раз для того, чтобы скрыть сложную и неуклюжую API Windows), отметим все-таки некоторые связанные с ней аспекты. Прежде всего, это касается типов данных. Хотя ранние версии Windows были написаны на Pascal, со временем Microsoft перешла на использование C и C++, поэтому типы данных в представлении Windows несколько отличаются от таковых в Delphi. Прежде всего, это касается строк: при работе с Windows напрямую следует использовать не обычные, а C-строки. В Object Pascal для этого предусмотрен специальный тип данных — PChar, а так же функции для преобразования строк одного вида в другой. Так, для преобразования Pascal-строк в C-строки используют функцию StrPCopy, а для обратного преобразования — функцию StrPas.
var
a: PChar;
s: string;
...
s:='Строка';
new(a); // для С-строк следует предварительно выделять память
StrPCopy(a,s); // содержимое Pascal-строки s скопировано в C-строку a
s:=StrPas(a);
Другие типы данных, часто используемые при работе с API — целые числа, булевы значения и указатели. В таких случаях можно использовать стандартные для Object Pascal типы данных, а к нужному виду они, при необходимости, будут приводиться автоматически.
СОВЕТ
В поставку Delphi включена документация по Windows API. Ссылки на файлы вы найдете в разделе MS SDK Help Files, вложенном в раздел Help программной группы Delphi в меню кнопки пуск. Наибольший интерес с точки зрения изучения функций API представляет собой файл Win32 Programmer’s reference.
Что касается VCL, то в Delphi все же имеется специальный компонент, который может отлавливать все сообщения, адресуемые приложению. Для этого существует компонент AppEvents, который принимает все сообщения, адресованные объекту Application. Среди событий, отслеживаемых компонентом AppEvents, выделим OnMessage — именно это событие происходит, когда приложение получает сообщение от Windows или иной программы. Кроме того, ряд компонент, на самом деле, являются оболочкой для вызова тех или иных функций Windows. Впрочем, о компонентах Delphi будет рассказано в следующей части этой книги.
« Черчение, рисование и печать
|
Работа с VCL в среде Delphi »
Техподдержка / Связаться с нами
Copyright © 1999-2020 SNK. Все права защищены.
При использовании материалов с сайта ссылка на источник обязательна.
Средняя общеобразовательная школа №14
г о Подольск МО
Практическое руководство по процедурам и функциям на языках
программирования PYTHON и JavaScript
Подготовил:
Учитель высшей категории
Глушков Николай Васильевич
предмет: информатика
Апрель
2022 г
Содержание
Введение.
Раздел1 Процедуры и функции на языке Python
1.1 Подпрограммы
1.2. Процедура с параметрами
1.3. Локальные и глобальные переменные
1.4. Язык Python функции
Раздел 2 Практикум решения задач
с использованием процедур и функций на языке
Python
Раздел 3 Программирование при помощи процедур и функций на языке JavaScript
( JS)
3.1.
Процедуры и функции на языке JavaScript
3.2 Хранение функции в JavaScript
3.3 Объявление функции
3.4 Параметры функции
3.5 Вызов функции
Раздел 4.Практикум решения задач
с использованием процедур и функций на языке
JavaScript
Заключение
Список литературы:
Введение
Настоящее
практическое
руководство по процедурам и функциям является продолжением, разработанной
ранее линии автора — по изучению и исследованию практического материала на
языках программирования Python и JavaScript.
Основной задачей данного пособия является – приобщение пользователей
— учащихся школы к управлению внутри блоков программы с помощью вспомогательных
алгоритмов. При конструировании достаточно сложного алгоритма логично разбивать
его на ряд более простых задач. Построение алгоритма идет «сверху вниз». Сначала
строится основной алгоритм. В нем записываются обращения к вспомогательным
алгоритмам, которые позволят решить отдельные, более простые задачи. Если есть
необходимость, осуществляют дальнейшую детализацию.
Итак, вспомогательным алгоритмом называется
алгоритм решения некоторой задачи, являющейся подчиненной по отношению к
основной задаче. При реализации таких алгоритмов на языках программирования их
оформляют в виде процедур или функций.
Согласно концепции структурного программирования,
вспомогательный алгоритм должен:
иметь имя, по которому его можно вызвать из других алгоритмов;
возвращать управление тому алгоритму, из которого он был вызван. После того как
завершится выполнение вспомогательного алгоритма, вызвавший его алгоритм
должен продолжить работу с той точки, в которой он был прерван;
Иметь возможность вызывать другие алгоритмы;
Иметь достаточно малые размеры.
В следующем разделе более подробно представлены сведения о процедурах и
функциях.
1
раздел. Процедуры
и функции на языке Python
Функции представляют блок кода, который выполняет определенную задачу и который можно повторно использовать в других частях программы. Формальное
определение функции: def имя_функции ( [параметры]): инструкции. Определение
функции начинается с выражения def, которое состоит из имени функции, набора
скобок с параметрами и двоеточия. Параметры в скобках необязательны. А со
следующей строки идет блок инструкций, которые выполняет функция.
https://labs-org.ru/python-3/
· Подпрограммы прежде всего необходимы в ситуации, когда в разных
частях программы необходимо выполнять одни и те же действия несколько раз. В
таком случае повторяемые операторы оформляются в виде функции или процедуры, к
которой можно обращаться и вызывать ее выполнение из разных частей программы.
·
В python существует два вида реализации подпрограмм: функции в роли процедуры и
функции в классическом понимании.
·
Функция в роли процедуры призвана не возвратить значение в основную программу,
а вывести его, либо выполнить какие-либо действия с глобальными переменными,
при этом не возвращая полученные значения основной программе (не используя
ключевое слово return).
Рассмотрим синтаксис функции-процедуры на примере:
Пример: Создать
процедуру для вывода сообщения об ошибке. Запрашивать у пользователя ввести
положительное число, в случае ввода отрицательного числа, вызывать процедуру
для вывода сообщения об ошибке.
✍ Решение:
def Err(): # определение процедуры
print ( "Ошибка: неверные данные" )
n = int ( input('введите положительное число') )
if n < 0:
Err() # вызов процедуры
·
Процедура — вспомогательный
алгоритм, выполняющий некоторые действия.
·
Это поименованный фрагмент
программы, который можно вызвать.
·
Процедура должна быть
определена к моменту её вызова. Определение процедуры начинается со служебного
слова def.
·
Вызов процедуры осуществляется
по ее имени, за которым следуют круглые скобки, например, Err().
·
В одной программе может быть
сколько угодно много вызовов одной и той же процедуры.
·
Использование процедур
сокращает код и повышает удобочитаемость.
ПРОЦЕДУРА
С ПАРАМЕТРАМИ
Как используются в Python параметры процедуры, рассмотрим на
примере.
Пример: Написать процедуру, которая печатает 60
раз указанный символ (введенный с клавиатуры), каждый с новой строки.
✍ Решение:
1
2
3
4
5
|
def printChar(s): for i in range(60): print (s) sim = input('введите символ') printChar(sim) |
·
Глобальная переменная — если ей присвоено
значение в основной программе (вне процедуры).
·
Локальная переменная (внутренняя) известна
только на уровне процедуры, обратиться к ней из основной программы и из других
процедур нельзя.
·
Параметры
процедуры — локальные переменные. В программе s — локальная
переменная.
Задание Python 3_0:
Создать процедуру, которая вычисляет разность двух вводимых пользователем
числа. Выполнить задание двумя способами: 1) процедура без параметров: числа —
глобальные переменные, определенные в основной программе; 2) процедура с
параметрами: числа — параметры процедуры.
ЛОКАЛЬНЫЕ И ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ
Примеры использования локальных и
глобальных переменных:
1
2
3
4
|
x = 3 # глобальная переменная def pr(): # процедура без параметров print (x) # вывод значения глобальной переменной pr() |
1
2
3
4
5
|
x = 3 # глобальная переменная def pr(a): # процедура с параметром a = 4 # локальная переменная print (a) # 4 pr(x) # передача параметра глобальной переменной (3) |
·
Существует возможность изменить значение глобальной переменной (не создавая
локальную). В процедуре с помощью слова global:
1
2
3
4
5
6
|
x = 3 # глобальная переменная def pr(): # процедура без параметров global x x = 1 print (x) # вывод измененного значения глобальной переменной (1) pr(x) |
Задание Python 3_1:
Напишите процедуру, которая выводит на экран в столбик все цифры переданного ей
числа, начиная с последней:
число: 4673
результат:
3
7
6
4
Задание Python 3_2:
Напишите процедуру, которая выводит на экран все делители переданного ей числа
(в одну строчку).
Задание Python 3_3:
Составить программу с процедурой для вычисления степени числа (входные
параметры: число и степень).
Рекомендации: для вычисления
степени числа можно использовать функцию pow(число, степень)
Задание Python 3_4:
Напишите процедуру, которая принимает параметр – натуральное число N – и выводит
первые N чисел
Фибоначчи.
Пример
использования ключевого слова global:
Поменять значений двух переменных.
✍ Решение:
Решение 1:
def Swap():
global x,y
t = x
x = y
y = t
x=3
y=5
Swap()
print(x,y)
Решение 2:
def Swap():
global x,y
(x, y) = (y, x)
(x,y)=(3,5)
Swap()
print(x,y)
Задание Python 3_5:
Создайте процедуру без параметров AddLeftDigit(), которая добавляет
введенную цифру K (0<=K<=9) слева к введенной цифре D (0<=D<=9) и
выводит результат. Используйте ключевое слово global для работы с
глобальными переменными.
Ожидаемый результат:
введите D (0<=D<=9) и K(0<=K<=9):
>>>2 >>>4
результат: 42
Язык Python функции
Часть функций языка Python являются
встроенными функциями, которые обеспечены синтаксисом самого языка.
Например, int, input, randint.
Рассмотрим пример создания пользовательских функций.
·
Функция
— это поименованный фрагмент программы, который можно вызвать.
·
Как и
процедура, функция должна быть определена к моменту её вызова (служебное
слово def).
·
Функция
в отличии от процедуры возвращает значение.
·
Для
возврата значения функции используется оператор return.
·
Вызов
функции осуществляется по ее имени и обычно сопровождается выводом значения.
Пример:
Найти максимальное значение из значений двух переменных.
✍ Решение:
def max(a,b):
if(a>b):
return a
else:
return b
x=int(input())
y=int(input())
print('max = ',max(x,y))
Задание Python 3_6:
Создайте функцию для поиска минимума среди трех чисел (три параметра функции).
Пример:
Вычислить сумму цифр числа.
1
2
3
4
5
6
7
8
|
def sumD(n): # определение функции с параметром sum = 0 while n!= 0: sum += n % 10 n = n // 10 return sum # возврат значения функции # основная программа
print (sumD(1075)) # вызов функции с параметром |
Задание Python 3_7:
Напишите функцию, которая вычисляет количество цифр числа.
Задание Python 3_8:
Создайте функцию, которая вычисляет сумму всех чисел от 1 до N. N — параметр функции.
Раздел 2 Практикум решения
задач с использованием процедур и
функций на языке Python
|
#Пример 1 Вычисление периметра и площади p=(a+b)*2 s=a*b return p,s print(f(3,5))
|
#Пример 2 Найти Максимальное значение x,y if x>y: max=x else: max=y return print(«max=»,maxf(23,63)) max= 63 |
|
#Пример3 Решение квадратного уравнения def kwur(a,b,c): d=b*b-4*a*c if d>=0: x1=round((-b+math.sqrt(d))/(2*a),(2)) x2=round((-b-math.sqrt(d))/(2*a),(2)) else: print(«нет вещественных корней») return x1,x2 #Основная пр a=int(input(«a=»)) b=int(input(«b=»)) c=int(input(«c=»)) print(kwur(a,b,c)) |
#Пример 4 Определение угла по координатам def grad(x,y): l=math.sqrt(x*x+y*y) if ((x > 0)and (y > 0 )): al=math.asin(y/l) grad = (180 / math.pi * al ) if ((x < 0)and (y > 0 )): al=math.asin(y/l) grad =180- (180 / math.pi * al ) if ((x < 0)and (y < 0 )): al=math.asin(y/l) grad = 180-(180 / math.pi * al ) if ((x > 0)and (y < 0 )): al=math.asin(y/l) grad = 360+(180 / math.pi * al ) return grad #основная программа a=int(input(«ввод a»)) b=int(input(«ввод b»)) print(round(grad(a,b),(2))) |
|
#Пример5 Вывести элементы ряда a=[1/(i*i) for s=sum(a) return a,s n=int(input(«n=»)) print(ryd(n)) |
Пример 6 def mas(n): import a=[] k=0 for i in if k+=1 print(k) return a n=int(input(«n=»)) print(mas(n)) |
|
#Пример 7 Массив а -> b отрицательные элементы def mas(n): k=0 b=[] for i in if k+=1 return n=int(input(«n=»)) print(mas(n)) Задание а -> b положительные элементы |
#Пример 8 Вывести элементы Ряд а : y=x*x/i import random import math def return y,s n=int(input(«n=»)) print(ryd(n)) |
|
#Пример 9 Построить ряд из случайных элементов import random import math def ryd(n): return z,s n=int(input(«n=»)) print(ryd(n)) |
#Пример 10 Построить ряд из случайных элементов import random def ryd(n): return z,s n=int(input(«n=»)) print(ryd(n)) |
|
#Пример11 Переписать элементы массива из a —à>b кратность 5 import math b=[] def ryd(n): for i in if return n=int(input(«n=»)) print(ryd(n)) |
#Пример 12 Построение ряда с точностью eps x=int(input(«x=»)) eps=0.0001 y=1 z=1 n=1 while abs(y) z=z+y n=n+1 print(«z=»,round(z,(2))) |
|
#Пример 13 Пример: ряд с факториалом def ryd(): y=1 z=1 x=4 n=1 while z=z+y n=n+1 return z eps=0.0001 print(ryd()) |
# Пример 14 Использование массивов Сумма цифр числа def sumD(n): sum = 0 while n!= sum += n % 10 n = n // 10 return sum # возврат значения функции # основная программа a=[12,123,456,768] for i in print |
|
Пример 15 # Факториал набор def f(n): p=1 for i in p=p*i return p a=[1,2,3,4,5,6,7,8,9,10] for i in n=a[i] |
Пример 16 # Ряд с факториалом x/1! +x^2/2! def f(n): p=1 for i in p=p*i return p a=[1,2,3,4,5,6,7,8,9,10] b=5 for i in n=a[i] x=i |
|
Пример 17 #Передача нечетных элементов из a->b import random def fun(n): s=0 a = for i in return n=int(input(«n=»)) print(fun(n)) |
Пример 18 #Фильтрация в массиве с передачей import random def fun(n): s=0 a = val=a for i in return n=int(input(«n=»)) def f1(val): f1(fun(n)) |
|
Пример 19 #Факториал печать p=1 for i in p=p*i return p #Основная пр m=int(input(«m=»)) for i in print(i-1,»!=»,f(i)) |
Пример 20 #Нахождение наибольшего элемента в max=0 for i in if return max print(«Ввод элементов массива») b=[12,34,8,6,45,3] for i in print(b[i],end=»,») print(«max=»,mas()) |
|
Пример 21# Найти все целые числа из промежутка 1=100, Где есть цифра “7” for i in n=a[i] d1 = n % 10 #Последняя if d1==7: print(n) n1 = n// 10 # целая d2 = n1 % 10 #Последняя if d2==7: print(n) |
Пример 22# Найти простое число def
print(
|
|||||||||||||||||||||
|
Пример 23 #Найти простые числа из массива if k==2 or k==3: return True if for i in if return a=[12,13,5,17,8,19,41] for i in |
Пример 24 #Найти простые числа из массива1 if k==2 or k==3: return True if for i in if return import for i in |
|||||||||||||||||||||
|
Пример 25 #Найти сумму ряда a=[(-1)**i*i**2 for i in range (1,n+1)] s=sum(a) return n=int(input(«n=»)) print(ryd(n)) |
Задачи для самостоятельного решения 26 Найти сумму ряда (2*n)^2 |
|||||||||||||||||||||
|
Пример 34 #Сложная функция def fun(n): b=[] for i in t=a[i]*4 return b n=int(input(«n=»)) a=[i for i in print(fun(n)) |
Пример 35 #ряд из арифметических корней def fun(n): b=[] for i in return b n=int(input(«n=»)) a=[i/10 for i |
|||||||||||||||||||||
|
Пример 36 #Напечатать таблицу стоимости конфет 100,200 z=int(input(«z=»)) zr=[] for i in return zr r=[i*100 for print(fun()) |
Пример 37 #Числа фибоначчи def fib(n): b=[] b.append(a[0]) b.append(a[1]) for i in return b n=int(input(«n=»)) a=[1,1] print(fib(n)) |
|||||||||||||||||||||
|
Пример 38 # Фильтрация по коду b=[] for i in return a,b n=int(input(«n=»)) import random a=[round(random.randrange(50)) print(fun(n)) |
Пример 39 #Размещения из n элементов поm def ras(n,m): p=1 for i in p=p*i nf=p p=1 for i in p=p*i nmf=p r=nf/nmf return r n=int(input(«n=»)) m=int(input(«m=»)) nm=n-m print(ras(n,m)) |
|||||||||||||||||||||
|
Пример 40 Сочетания из n элементов по m def soh(n,m): p=1 for i in p=p*i nf=p p=1 for i in p=p*i nmf=p p=1 for i in p=p*i mf=p return c n=int(input(«n=»)) m=int(input(«m=»)) nm=n-m print(soh(n,m)) |
41 Пример рекурсии print(n) if n < F(n + 1) F(n + 3) return F n=int(input(«n=»)) print(F(n)) |
|||||||||||||||||||||
|
Раздел 3
Функция (в общем случае) — это отношение между элементами, при котором Функция в JavaScript — это специальный тип объектов, позволяющий Функции позволяют не повторять Функция: · · · 1. входные 2. те переменные, которые объявляются · Процедура — это функция, которая Метод — это функция, которая является свойством объекта. Важно · Замечание В JavaScript любая функция — это объект, и следовательно, ею можно манипулировать как объектом, в 1. 2. Примеры Хорошим тоном в программировании 3.2 ХРАНЕНИЕ ФУНКЦИЙ В JS В JavaScript функции могут храниться тремя способами: 1. в переменной: ·
2. в объекте: ·
3. в массиве: ·
Объявлять функции в JavaScript можно с помощью 1. 2. 3.3 ОБЪЯВЛЕНИЕ ФУНКЦИИ (FUNCTION DECLARATION) Для создания функций используется её объявление, например:
где · · · ·
Разбор примера Таким образом, объявление функции, кроме В объектно-ориентированном Выбор имени функции ОБЪЯВЛЕНИЕ ФУНКЦИИ (FUNCTION EXPRESSION) Существует ещё один синтаксис создания Синтаксис:
где · · ·
Примеры 3.4 ПАРАМЕТРЫ (АРГУМЕНТЫ) ФУНКЦИИ Мы можем передать внутрь функции любую Параметр функции — это переменная, которая используется в функции и Аргумент функции — это значение, которое передаётся в функцию (указывается
В примере выше в Параметры функции по умолчанию установлены на undefined. Синтаксис «оставшиеся параметры» Особенности 1. Параметры, 2. Определения 3. Функции 4. Функции Особенности 1. 2. Пример Параметры по умолчанию См. также ES6 значения по умолчанию: базовый пример Если параметр не указан, то его значением становится undefined:
В вызове не указан параметр lastName, поэтому Если мы хотим задать параметру функции
В JavaScript параметры по умолчанию вычисляются каждый раз, 3.5 ВЫЗОВ ФУНКЦИИ Объявление функции не выполняет её.
Таким образом, для того Раздел
|
||||||||||||||||||||||
|
Пример1 Вычисление площади треугольника <HEAD> <title>Использование сценария с <script language=»JavaScript»> <!— // Function plosh (a, h) //—> </script> </HEAD> <BODY> <Р>Начало отображения страницы со <script> <!— var al=4; hl=16; var s=plosh(al,hl) document.write(«При вызове функции //—> </script> <Р>Конец формирования </BODY> </HTML> . |
Пример2 Площадь треугольника с классом форм <HEAD> <script language=»JavaScript»> <!— // function pl (a, h ) { var s= (a.value* h.value)/2 ; document.writeln («Площадь return s}; //—> </script> </HEAD> <BODY> <Р>Вычисление площади <FORM name=»forml»> Основание: Высота: <input type=»button» value=Bычиcлить onClick=»pl(forml.st1, forml.st2)»> </FORM> </BODY> </HTML> |
|||||||||||||||||||||
|
Пример 3 Формула Герона для вычисления <HEAD> <title>Имена полей формы в качестве параметров</title> <script <!— // function pl(a,b,c { var p=(a.value+b.value+c.value); document.writeln return p}; //—> </script> <Р>Вычисление площади треугольника</Р> <FORM 1 сторона: <input type=»text» size=6 2 сторона: <input type=»text» size=6 3 сторона: <input type=»text» size=6 <input onClick=»pl(forml.st1, </FORM></BODY></HTML> Пример <Script> function max=0; for a=Number(prompt(«wwod if (a%5==0 max=a; } } return max; } n=Number(prompt(«ввод document.writeln(zad(n)); </Script> Пример 7 Создание массива через функцию random * <HEAD> <title>Массив</title> <Script <!— // function var s = 0;
Пример 8 Нахождение суммы в массиве
var a=[]; for (var y=(Math.random()*100).toFixed(0); s+=Number(y); a.push(y); } document.writeln(a,»,»); document.writeln(«sum=»,s); } //—> </Script> </HEAD> <BODY> <Р>Массив</Р> <FORM ввод n: <input type=»text» size=6 <input </FORM> </BODY> </HTML> |
Пример 4 Вычисление факториала <Script> function f(nn){ p=1; for(n=1;n<=nn;n++){ p=p*n; } return p; } nn=Number(prompt(“nn=”)) document.writeln(f(nn)); </Script> ———————————————————————— <HTML> <HEAD><title>Имена полей формы в качестве <Script language=»JavaScript»><!— function var var var for(i=0;i<=k;i++){ d; document.write(«f=» } } //—> </Script></HEAD> <BODY> <FORM конеч знач: коэффициент знач функции: <input type=»text» Диапазон random:<input type=»text» size=6 <input </FORM></BODY></HTML> |
|||||||||||||||||||||
|
Пример 9 Сумма цифр натурального числа <HTML> <HEAD> <title>сумма цифр натурального числа</title> <script language=»JavaScript»> <!— // function var return } function var s = 0; while } document.writeln(«<br>»); document.writeln(s); } //—> </script> </HEAD> <BODY> <Р>сумма цифр натурального числа</Р> <FORM ввод числа:
Пример 11 Добавление данных в массив <Script> function fr(n){ const fr = [‘banana’, ‘pear’, ‘apple’]; fr.push(‘mango’, ‘melon’, ‘avocado’); return fr; } n=Number(prompt(«n=»,»»)); document.write(fr(n),»,»); </Script>
<input type=»button» value=Bычиcлить onClick=»a(forml.st1.value)»> </FORM> </BODY> </HTML> |
Пример 10 Нахождение максимального элемента в созданном массиве <html> <Script> function var var max=0; for(var if (y*a[n] var } } document.writeln(«max=»,max); } </Script> <body> <form> <input </form> </body> </html> |
|||||||||||||||||||||
|
Пример 12 Объединение двух массивов function b=[12,34,56,78,87,23]; a.push(b); return a; } n=Number(prompt(«n=»,»»)); a = document.writeln(ryd(n),»,»); </Script> |
Пример Преобразование массивов <Script> function ryd(n){ c=[]; for(i=1;i<=5;i++){ b=(a[i]*Math.random()*100).toFixed(2); c.push(b); } return c; } n=Number(prompt(«n=»,»»)); a = document.writeln(ryd(n),»,»); </Script> |
|||||||||||||||||||||
|
Пример 13 Создание базы данных <HTML> <HEAD> <title>база <Script function var s=0; var document.write(nm,»,»); document.writeln(«<BR>»); for var kl=(Math.random()*200).toFixed(0); zn=(Math.random()*1000).toFixed(0); st=kl*zn; s+=st; document.write(st,»,»); } document.writeln(«<BR>»); document.write(«s=» } </Script> </HEAD> <BODY> <Р>база <FORM <input </FORM> </BODY> </HTML> |
Пример: 14 передача случайных данных в пустой массив Пример Организация массива через функцию Script> function a=[]; s=0; for y=Math.random()*100; a.push(y.toFixed(0)); s+=Number(y); } document.writeln(a,»,») return s; } n=Number(prompt(«ввод document.writeln(mas(n).toFixed(1)); </Script> |
|||||||||||||||||||||
|
Пример 15 Вычисление площади треугольника с классом <FORM> <HTML> <HEAD> <script language=»JavaScript»> <!— // function var s= document.writeln return s; } //—> </script> </HEAD> <BODY> <Р>Вычисление площади треугольника</Р> <FORM Основание: Высота: <input </FORM> </BODY> </HTML> |
Пример 15.1 Заполнение пустого массива function var a=[]; for (var y=(Math.random()*100).toFixed(2); a.push(y); } return a; } n=Number(prompt(«ввод n»,»»)); document.writeln(mas(n)); </Script> |
|||||||||||||||||||||
|
Пример 16 организации нового массива из 2-х данных массивов * <Script> function f(){ b=[12,23,34,45]; for(i = 0;i b.push(a[i]*5); }return b; } var document.writeln(f(),»,»); </Script> |
Пример 17 создания рекурсии * <Script> function F(n){ document.write(n); if (n < F(n + 1); F(n + 3); } return ; } n=Number(prompt(«ввод document.write(F(n)); </Script> |
|||||||||||||||||||||
|
Пример 18 решение квадратного уравнения * <HTML> <HEAD> <title>квадратное уравнение</title> <script <!— // function var if (d>=0){ var var document.writeln(«x1=»,x1); document.writeln(«x2=»,x2); } else{ document.writeln(«no»); } } //—> </script> </HEAD> <BODY> <Р>квадратное уравнение</Р> <FORM name=»forml»> ввод a: ввод b: ввод c <input </FORM> </BODY> </HTML> |
Пример 19 вычисления суммы членов арифметической <HTML> <HEAD> <title>арифм <Script <!— // function var var document.writeln(«s=»,s); } //—> </Script> </HEAD> <BODY> <Р>арифм прогрессия</Р> <FORM ввод a: ввод b: ввод c <input </FORM> </BODY> </HTML> |
|||||||||||||||||||||
|
Пример 20 Решение задачи на сочетания * <HTML> <HEAD> <title>сочетания</title> <Script <!— // function (p)=1; for( (p)=(p)*i; } (k)=1; for( (k)=(k)*i; } (l)=1; for( (l)=(l)*i; } document.write(«c=»,c); } //—> </Script> </HEAD> <BODY> <Р>Сочетания</Р> <FORM ввод n: <input type=»text» size=6 ввод m: <input type=»text» size=6 <input </FORM> </BODY> </HTML> |
Пример 21 блок факториалов * <HTML> <HEAD> <title>факториал</title> <Script <!— // function a=[2,3,4,5,6,7,8,9]; for( n=a[i]; p=1; for( (p)=(p)*j; } document.write(a[i],»!=»,p,»,»); } } //—> </Script> </HEAD> <BODY> <Р>факториал</Р> <FORM <input </FORM> </BODY> </HTML> |
|||||||||||||||||||||
|
Задачи для самостоятельного решения 1. Вычисление 2. Вычисление 3. Вычисление 4. Вычисление 5. Вычисление 6. Вычисление 7. Вычисление 8. Вычисление 9. Вычисление 10 Вычисление 11 Вычислить Вычисление 12. Вычисление |
Заключение
Настоящее практическое руководство,
с использованием функций и процедур на языках программирования PYTHON и JavaScript , носит поисково-
исследовательский характер. Решение задач в данном
руководстве является продолжением методической линии, которая была предложена
настоящим автором в практикумах по программированию на языках PYTHON и JavaScript. Для учащихся школ данный практикум является, как бы
справочным материалом, для дальнейшего изучения и исследования функций и
подпрограмм при решении задач структурного программирования.
Автором показаны не только простые задачи с применением функций и процедур,
но и задачи, например, с классом Form.
Задачи такого типа представляют собой как бы оболочку, в которой рождаются
решения. В ранних работах автора представлены так же задачи структурного
программирования с виджетами, которые решаются с помощью библиотек на языках
программирования PYTHON и JavaScript. Список авторских работ,
опубликованных на учительском сайте для ознакомления представлен в разделе –
Список литературы.
Желаю успехов в освоении данного
материала!
Список литературы:
6.https://infourok.ru/user/glushkov-nikolay-vasilevich/materi
Войти на сайте МЭШ
Войдите с учетной записью ученика или учителя МЭШ,
чтобы получить доступ к личному кабинету.
|
Подпрограммы: введение ПодпрограммыПодпрограмма — это отдельная часть программы, имеющая имя и решающая свою отдельную задачу. Располагается подпрограмма в начале основной программы и может быть запущена (вызвана) из основной программы по указанию имени.
Использование подпрограмм позволяет избежать дублирования кода, в случае если необходимо один и тот же код писать в разных местах программы. Каждая подпрограмма должна решать только одну задачу, либо только что-то вычислять, либо выводить какие-либо данные, либо делать что-то еще. Подпрограммы бывают двух типов — процедуры и функции. Подпрограммы-процедуры выполняют некоторые действия, например, выводят результат на экран в определенном виде (простой пример, оператор Подпрограммы-функции возвращают результат (число, символьную строчку и т.д.), который мы можем использовать в основной программе. Давайте попробуем написать простую процедуру: print("Error")
А теперь представим, что такую строчку нужно вставить во многих местах программы. Конечно, можно везде ее просто написать. Но это решение имеет два недостатка. Для таких случаев процедуры и нужны. def printError(): # описание процедуры
print("Error")
...
printError() # запуск процедуры на выполнение.
# Просто указываем имя процедуры, которую хотим выполнить
...
printError()
Надо запомнить!
Задача для тренировки:Подпрограммы: введение |
||||||||
|
Параметры и аргументы Параметры и аргументы
А теперь представим, что нам необходимо в ответ на ошибку пользователя вывести разные сообщения, в зависимости от того, какую именно ошибку он сделал. def printErrorZero():
print("Error. Division by zero!")
def printErrorInput():
print("Error in input!")
А если возможных ошибок будет намного больше? Такое решение нам не подойдет! def printError(s):
print("s")
В данной процедуре Параметр — это переменная, от значения которой зависит работа подпрограммы. Имена параметров перечисляются через запятую в заголовке подпрограммы. Теперь при вызове процедуры нужно в скобках указывать фактическое значение, которое будет присвоено параметру (переменной printError("Error! Division by zero!")
Такое значение называется аргументом. Аргумент — это значение параметра, которое передается подпрограмме при ее вызове. Аргументом может быть не только постоянное значение, но и переменная или арифметическое выражение. Задача для тренировки:Параметры и аргументы |
||||||||
|
Локальные и глобальные переменные Локальные и глобальные переменныеПеременные, которые введены в основной программе, называются глобальные (или общие). Обращаться к глобальным переменным можно из любой подпрограммы. Часто необходимо ввести дополнительные переменные, которые будут использоваться только в подпрограмме. Такие переменные называются локальными (или местными). С ними можно работать только внутри той подпрограммы, в которой они созданы. Остальные подпрограммы про них ничего не «знают». Таким образом, можно ограничить область действия (область видимости) переменной только той подпрограммой, где она действительно нужна. В программировании такой прием называется инкапсуляцией — сокрытие переменной от ее изменения извне. Проанализируйте три программы:
Задача для тренировки:Локальные и глобальные переменные |
Подборка по базе: Цифровая экономика лаб практикум 1.docx, Общий Психологический Практикум Практическое задание.docx, практическая лаб. практикум.docx, ЛАБОРАТОРНЫЙ ПРАКТИКУМ 1 РЕШЕНИЕ.docx, Детская литература с практикумом по выразительному чтению.docx, Практическое задание по дисциплине Общепсихологический практикум, Урп практикум.docx, Практическое задание по дисциплине Общепсихологический практикум, Лабораторный практикум 2.docx, ТЕСТЫ Теория и методика музыкального воспитания с практикумом.do
Функции (процедуры)
Процедуры и функции — это подпрограммы, которые могут многократно вызываться основной программой.
Пример: Создать процедуру для вывода сообщения об ошибке. Запрашивать у пользователя ввести положительное число, в случае ввода отрицательного числа, вызывать процедуру для вывода сообщения об ошибке.
Пример процедуры:
def Err(): # определение процедуры
print ( «Ошибка: неверные данные» )
n = int ( input() )
if n < 0:
Err() # вызов процедуры
Функции, в отличие от процедур, вызываются как значения величин. Внутри функции имеется команда return (вернуть)
Пример функции:
def Err(): # определение функции
return «Ошибка: неверные данные»
n = int ( input() )
if n < 0:
print(Err()) # вызов функции
Обратите внимание
Процедуры и функции начинаются ключевым словом def после которого мы пишем её имя, которое сами придумываем. После открывающей и закрывающей скобки ставим «:» Команды внутри функции пишут с отступом
Процедуры и функции должны быть описаны до его вызова.
Аргументы (параметры) функций и процедур
Пример: Написать процедуру, которая печатает 60 раз указанный символ (введенный с клавиатуры), каждый с новой строки.
def printChar(s): # s это аргумент функции
for i in range(60):
print (s)
sim = input(‘введите символ’)
printChar(sim)
Глобальная переменная — если ей присвоено значение в основной программе (вне процедуры).
Локальная переменная (внутренняя) известна только на уровне процедуры, обратиться к ней из основной программы и из других процедур нельзя.
Параметры процедуры — локальные переменные. В программе s — локальная переменная.
x = 3 # глобальная переменная
def pr(): # процедура без параметров
print (x) # вывод значения глобальной переменной
pr()
x = 3 # глобальная переменная
def pr(a): # процедура с параметром
a = 4 # локальная переменная
print (a) # 4
pr(x) # передача параметра глобальной переменной
Существует возможность изменить значение глобальной переменной (не создавая локальную). В процедуре с помощью слова global:
x = 3 # глобальная переменная
def pr(): # процедура без параметров
global x
x = 1
print (x) # вывод измененного значения глобальной переменной
pr(x)
Задания:
- Напишите процедуру, которая выводит на экран построчно цифры переданного ей двузначного числа
- Напишите функцию maxi (a,b), которая выводит на экран большую из двух чисел
- Напишите функцию sum(n), которая возвращает сумму чисел от 1 до n (используйте цикл)
Рекурсия
Рекурсия это ситуация, когда функция или процедура вызывает себя сама
Решим задачу
Имеется число 12345. Сколько ещё чисел можно получить, переставляя цифры этого числа?
Эта задача из комбинаторики. Число перестановок из n элементов, равно n! =1*2*3…n (n факториал)
def fact(n):
if n == 1:
return n
else:
return n*fact(n-1)
print(fact(5))
Ещё задача
Вычисление n-го числа ряда Фибоначчи
Числа Фибоначчи это числа 1,1,2,3,5,8… где каждое число начиная с 3-го равна сумме двух пердыдущих
def fibonacci(n):
if n in (1, 2):
return 1
return fibonacci(n — 1) + fibonacci(n — 2)
print(fibonacci(10))
Обратите внимание:
Эти задачи можно решить и без рекурсии, используя цикл
Задание:
- Найдите с помощью рекурсивной функции факториал числа 15.
- Решите задачу. Сколько способов существует выбрать двух дежурных из 20 учащихся. Используйте формулу:
Для вычисления факториала используйте рекурсивную функцию - Решите задачу (числа Фибоначчи):
В начале января пару новорождённых кроликов (самца и самку) поместили в загон, огороженный со всех сторон. Сколько пар кроликов они произведут к началу следующего года? Необходимо учесть такие условия:
- Кролики достигают половой зрелости через два месяца после своего рождения, то есть к началу третьего месяца жизни.
- В начале каждого месяца каждая половозрелая пара даёт жизнь только одной паре.
- Животные всегда рождаются парами «одна самка + один самец».
- Кролики бессмертны, их не могут съесть хищники.