Python

4 5

2 5

Пример выходных данных

* 2 1 2 1 1 2 * 2 *

. 2 2 4 2

. 1 * 2 *

>>n, m, k = ( int(i) for i in input().split() ) # вводим количество строк, столбцов, мин

>>a = [ [0 for j in range(m) ] for i in range(n) ] # создаем массив n×m из нулей

>>for i in range(k):

row, col = ( int(i) - 1 for i in input().split() )

a[row][col] = -1 # клеткам с минами присваиваем значение -1

# считаем количество соседних клеток с минами

>> for i in range(n) : for j in range(m) :

if a[ i ][ j ] == 0:

# перебираем все клетки со смещением ± 1

for di in range(-1, 2): # смещение по строке

for dj in range(-1, 2): # смещение по столбцу ai = i + di # координата строки

aj = j + dj # координата столбца

#проверяем, не попала ли клетка (ai; aj) за пределы поля

иесть ли там мина

if 0 <= ai < n and 0 <= aj < m and a[ ai ][ aj

] == -1:

# клетка (ai; aj) содержит мину и граничит с клеткой a[ i ][ j ]

a[ i ][ j ] += 1 # увеличиваем количество таких клеток для a[ i ][ j ] на 1

# выводим поле игры на экран

>> for i in range(n): for j in range(m):

if a[ i ][ j ] == -1: print( ' * ', end=' ')

elif a[ i ][ j ] == 0: print( ' . ', end=' ')

ГЛАВА 3

Функции

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

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

РАЗДЕЛ 1

Основы реализации функции

Зачем нужны функции?

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

Максимизировать многократное использование программного кода и минимизировать его избыточность

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

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

Процедурная декомпозиция

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

Создание функций

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

Python:

Def – это исполняемый программный код. Функции в языке Python создаются с помощью новой инструкции def. В отличие от функций в компилирующих языках программирования, таких как C, def относится к классу исполняемых инструкций – функция не существует, пока

РАЗДЕЛ 2

Области видимости

Область видимости - области, где определяются переменные и выполняется их поиск.

Всегда, когда в программе используется какое-то имя, интерпретатор создает, изменяет или отыскивает это имя в пространстве имен – в области, где находятся имена.

Пространство имён определяет отображение имён в объекты.

В языке Python большинство пространств имен реализованы как список, что, однако, не влияет на работу программы (кроме производительности) и может быть изменено. Вот несколько примеров пространств имён: множество встроенных имён (функции, исключения), глобальные имена в модуле, локальные имена при вызове функций. Здесь атрибуты объекта также образует пространство имён. Важно понимать, что между именами в разных пространствах имён нет связи. К примеру, несколько модулей могут определить функции с именем "function" не создавая при этом путаницы — мы должны ссылаться на них с использованием имени модуля в качестве приставки.

Под словом атрибут мы подразумеваем любое имя, следующее после точки: например, в выражении object.cool , cool– это атрибут объекта object. Сам же object является объектом-модулем.

В этом случае имеет место прямое соответствие между атрибутами модуля и глобальными именами, определёнными в модуле: они совместно используют одно пространство имён !

Атрибуты могут быть как доступны для чтения, так и допускать присваивание. Во втором случае Вы можете присвоить 'object.risk = 1337' или удалить его, используя инструкцию del: 'del object.risk'.

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

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

•Поиск имени производится во внутренней области видимости (содержит локальные имена)

•Затем – в средней (содержит глобальные имена )

•И, наконец, во внешней (содержащей встроенные имена)

Как правило локальная область видимости соответствует локальному пространству имён текущей функции (класса, метода). За пределами функции (класса, метода), локальная область видимости соответствует тому же пространству имён, что и глобальная: пространству имён текущего модуля.

Главное – понять, что область видимости определяется по тексту: глобальная область видимости функции, определенной в модуле — пространство имён этого модуля, независимо от того, откуда или под каким псевдонимом функция была вызвана. С другой стороны, поиск имён происходит во время выполнения программы(динамически).

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

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

зарезервированного слова global достаточно ясно показывает, что переменная объявлена в самом внешнем блоке.

Пример области видимости

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

# Глобальная область видимости

X = 99 # X и func определены в модуле: глобальная область

def func(Y): # Y и Z определены в функции: локальная область

# Локальная область видимости

Z = X + Y # X – глобальная переменная

return Z

func(1) # func в модуле: result=100

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

Глобальные имена: X и func

X – это глобальное имя, так как она объявлена на верхнем уровне модуля. К ней можно обращаться внутри функции, не объявляя ее глобальной.

func – это глобальное имя по тем же причинам. Инструкция def связывает объект функции с именем func на верхнем уровне модуля.

Локальные имена: Y и Z

Имена Y и Z являются локальными (и существуют только во время выполнения функции), потому что присваивание значений обеим именам осуществляется внутри определения функции: присваивание переменной Z производится с помощью инструкции =, а Y – потому что аргументы всегда передаются через операцию присваивания.

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

– эти имена не пересекаются с вмещающим пространством имен модуля (или с пространствами имен любых других функций).

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

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

РАЗДЕЛ 3

Аргументы

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

def функция (параметр1, параметр2):

Тело функции

…

функция (аргумент1, аргумент2)

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

Функция может принимать произвольное количество аргументов или не принимать их вовсе. Также распространены функции с произвольным числом

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

И так:

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

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

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

Схема передачи аргументов:

• Неизменяемые объекты передаются «по значению». Такие объекты, как целые числа и строки, передаются в виде ссылок на объекты, а не в виде копий объектов, но так как неизменяемые объекты невозможно изменить

непосредственно, передача таких объектов очень напоминает копирование.

• Изменяемые объекты передаются «по указателю». Такие объекты, как списки и словари, также передаются в виде ссылок на объекты, что очень похоже на то, как в языке C передаются указатели на массивы, – изменяемые объекты допускают возможность непосредственного изменения внутри функции так же, как и массивы в языке

C.

Варианты аргументов:

• Обязательные аргументы

def func(a, b):

return a+b

func(1, 4)

func(a=1, b=4) # Именованные аргументы

• Необязательные аргументы

def func(a, b, c=3): # c –необязательный

return a+b+c

func(1, 4) # 1+4+3 = 8

func(1, 4, 2) # 1+4+2 =7

def func(a, b=5, c=3):

return a+b+c

func(1, c=2) # 1+5+2 = 8

Комбинирование именованных аргументов и значений по умолчанию:

def func(spam, eggs, toast=0, ham=0): # Первые 2 являются обязательными

print(spam, eggs, toast, ham)

func(1, 2) # Выведет: (1, 2, 0, 0)

func(1, ham=1, eggs=0) # Выведет: (1, 0, 0, 1)

func(spam=1, eggs=0) # Выведет: (1, 0, 0, 0)

func(toast=1, eggs=2, spam=3) # Выведет: (3, 2, 1, 0)

func(1, 2, 3, 4) # Выведет: (1, 2, 3, 4)

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

Произвольное число аргументов:

•Обозначается звездочкой перед аргументом - *args

•Внутри функции выглядит как кортеж, элементы кортежа расположены в том же порядке, что и аргументы функции, указанные при вызове.