Файл: Книга на вашем родном языке 6 2 Переводы 7 1 Доступные переводы переводы 7 3 Предисловие 16.pdf
ВУЗ: Не указан
Категория: Не указан
Дисциплина: Не указана
Добавлен: 10.01.2024
Просмотров: 235
Скачиваний: 2
ВНИМАНИЕ! Если данный файл нарушает Ваши авторские права, то обязательно сообщите нам.
A Byte of Python (Russian), Версия 2.02 9.4.1 Поэтический Python Swaroop’а
Для ввода строк здесь я использовал мини-стишок, который сам сочинил. Он называется
Поэтический Python Swaroop’а
8
Программировать весело.
Если работа скучна,
Чтобы придать ей весёлый тон - используй Python!
9.5 Оператор continue
Оператор continue используется для указания Python, что необходимо пропустить все оставшиеся команды в текущем блоке цикла и продолжить
9
со следующей итерации цик- ла.
Пример: (сохраните как continue.py
)
while True
:
s
=
input
(
'Введите что-нибудь : '
)
if
s
==
'выход'
:
break
if len
(s)
<
3
:
(
'Слишком мало'
)
continue
(
'Введённая строка достаточной длины'
)
# Разные другие действия здесь...
Вывод:
$ python continue.py
Введите что-нибудь : a
Слишком мало
Введите что-нибудь : 12
Слишком мало
Введите что-нибудь : абв
Введённая строка достаточной длины
Введите что-нибудь : выход
8
Swaroop’s Poetic Python:
Programming is fun.
When the work is done,
if you wanna make your work also fun:
use Python!
9
continue – англ. «продолжать» (прим.перев.)
9.5. Оператор continue
62
A Byte of Python (Russian), Версия 2.02
Как это работает:
В этой программе мы запрашиваем ввод со стороны пользователя, но обраба- тываем введённую строку только если она имеет длину хотя бы в 3 символа.
Итак, мы используем встроенную функцию len для получения длины строки,
и если длина менее 3, мы пропускаем остальные действия в блоке при помо- щи оператора continue
. В противном случае все остальные команды в цикле выполняются, производя любые манипуляции, которые нам нужны.
Заметьте, что оператор continue также работает и с циклом for
9.6 Резюме
Мы увидели, как использовать три оператора для управления потоком команд:
if
,
while и
for
, а также связанные с ними операторы break и
continue
. Это наиболее часто ис- пользуемые конструкции Python, поэтому овладеть ими очень важно.
Далее мы увидим, как создавать и использовать функции.
9.6. Резюме
63
Функции
Функции – это многократно используемые фрагменты программы. Они позволяют дать имя определённому блоку команд с тем, чтобы впоследствии запускать этот блок по ука- занному имени в любом месте программы и сколь угодно много раз. Это называется вы-
зовом функции. Мы уже использовали много встроенных функций, как то len и
range
Функция – это, пожалуй, наиболее важный строительный блок любой нетривиальной про- граммы (на любом языке программирования), поэтому в этой главе мы рассмотрим раз- личные аспекты функций.
Функции определяются при помощи зарезервированного слова def
. После этого слова указывается имя функции, за которым следует пара скобок, в которых можно указать имена некоторых переменных, и заключительное двоеточие в конце строки. Далее сле- дует блок команд, составляющих функцию. На примере можно видеть, что на самом деле это очень просто:
Пример: (сохраните как function1.py
)
def
sayHello
():
(
'Привет, Мир!'
)
# блок, принадлежащий функции
# Конец функции
sayHello()
# вызов функции
sayHello()
# ещё один вызов функции
Вывод:
$ python function1.py
Привет, Мир!
Привет, Мир!
Как это работает:
Мы определили функцию с именем sayHello
, используя описанный выше синтаксис. Эта функция не принимает параметров, поэтому в скобках не объ- явлены какие-либо переменные. Параметры функции – это некие входные данные, которые мы можем передать функции, чтобы получить соответству- ющий им результат.
64
A Byte of Python (Russian), Версия 2.02
Обратите внимание, что мы можем вызывать одну и ту же функцию много раз, а значит нет необходимости писать один и тот же код снова и снова.
10.1 Параметры функций
Функции могут принимать параметры, т.е. некоторые значения, передаваемые функции для того, чтобы она что-либо сделала с ними. Эти параметры похожи на переменные, за исключением того, что значение этих переменных указывается при вызове функции, и во время работы функции им уже присвоены их значения.
Параметры указываются в скобках при объявлении функции и разделяются запятыми.
Аналогично мы передаём значения, когда вызываем функцию. Обратите внимание на терминологию: имена, указанные в объявлении функции, называются параметрами, то- гда как значения, которые вы передаёте в функцию при её вызове, – аргументами.
Пример: (сохраните как func_param.py
)
def
printMax
(a, b):
if
a
>
b:
(a,
'максимально'
)
elif
a
==
b:
(a,
'равно'
, b)
else
:
(b,
'максимально'
)
printMax(
3
,
4
)
# прямая передача значений
x
=
5
y
=
7
printMax(x, y)
# передача переменных в качестве аргументов
Вывод:
$ python func_param.py
4 максимально
7 максимально
Как это работает:
Здесь мы определили функцию с именем printMax
, которая использует два параметра с именами a
и b
. Мы находим наибольшее число с применением простого оператора if..else и выводим это число.
При первом вызове функции printMax мы напрямую передаём числа в ка- честве аргументов. Во втором случае мы вызываем функцию с переменными
10.1. Параметры функций
65
A Byte of Python (Russian), Версия 2.02
в качестве аргументов.
printMax(x, y)
назначает значение аргумента x
па- раметру a
, а значение аргумента y
– параметру b
. В обоих случаях функция printMax работает одинаково.
10.2 Локальные переменные
При объявлении переменных внутри определения функции, они никоим образом не свя- заны с другими переменными с таким же именем за пределами функции – т.е. имена переменных являются локальными в функции. Это называется областью видимости пере- менной. Область видимости всех переменных ограничена блоком, в котором они объяв- лены, начиная с точки объявления имени.
Пример: (сохраните как func_local.py
)
x
=
50
def
func
(x):
(
'x равен'
, x)
x
=
2
(
'Замена локального x на'
, x)
func(x)
(
'x по-прежнему'
, x)
Вывод:
$ python func_local.py x равен 50
Замена локального x на 2
x по-прежнему 50
Как это работает:
При первом выводе значения, присвоенного имени x
, в первой строке функции
Python использует значение параметра, объявленного в основном блоке, выше определения функции.
Далее мы назначаем x
значение
2
. Имя x
локально для нашей функции. По- этому когда мы заменяем значение x
в функции,
x
, объявленный в основном блоке, остаётся незатронутым.
Последним вызовом функции print мы выводим значение x
, указанное в ос- новном блоке, подтверждая таким образом, что оно не изменилось при ло- кальном присваивании значения в ранее вызванной функции.
10.2. Локальные переменные
66
A Byte of Python (Russian), Версия 2.02 10.3 Зарезервированное слово «global»
Чтобы присвоить некоторое значение переменной, определённой на высшем уровне про- граммы (т.е. не в какой-либо области видимости, как то функции или классы), необходимо указать Python, что её имя не локально, а глобально (global). Сделаем это при помощи заре- зервированного слова global
. Без применения зарезервированного слова global невоз- можно присвоить значение переменной, определённой за пределами функции.
Можно использовать уже существующие значения переменных, определённых за преде- лами функции (при условии, что внутри функции не было объявлено переменной с таким же именем). Однако, это не приветствуется, и его следует избегать, поскольку человеку,
читающему текст программы, будет непонятно, где находится объявление переменной.
Использование зарезервированного слова global достаточно ясно показывает, что пере- менная объявлена в самом внешнем блоке.
Пример: (сохраните как func_global.py
)
x
=
50
def
func
():
global
x print
(
'x равно'
, x)
x
=
2
(
'Заменяем глобальное значение x на'
, x)
func()
(
'Значение x составляет'
, x)
Вывод:
$ python func_global.py x равно 50
Заменяем глобальное значение x на 2
Значение x составляет 2
Как это работает:
Зарезервированное слово global используется для того, чтобы объявить, что x
– это глобальная переменная, а значит, когда мы присваиваем значение име- ни x
внутри функции, это изменение отразится на значении переменной x
в основном блоке программы.
Используя одно зарезервированное слово global
, можно объявить сразу несколько переменных:
global x, y, z
10.3. Зарезервированное слово «global»
67
A Byte of Python (Russian), Версия 2.02 10.4 Зарезервированное слово «nonlocal»
Мы увидели, как получать доступ к переменным в локальной и глобальной области ви- димости. Есть ещё один тип области видимости, называемый «нелокальной» (
nonlocal
)
областью видимости, который представляет собой нечто среднее между первыми дву- мя. Нелокальные области видимости встречаются, когда вы определяете функции внутри функций.
Поскольку в Python всё является выполнимым кодом, вы можете определять функции где угодно.
Давайте рассмотрим пример:
# Filename: func_nonlocal.py
def
func_outer
():
x
=
2
(
'x равно'
, x)
def
func_inner
():
nonlocal
x x
=
5
func_inner()
(
'Локальное x сменилось на'
, x)
func_outer()
Вывод:
$ python func_nonlocal.py x равно 2
Локальное x сменилось на 5
Как это работает:
Когда мы находимся внутри func_inner
, переменная x
, определённая в пер- вой строке func_outer находится ни в локальной области видимости (опре- деление переменной не входит в блок func_inner
), ни в глобальной обла- сти видимости (она также и не в основном блоке программы). Мы объявля- ем, что хотим использовать именно эту переменную x
, следующим образом:
nonlocal x
Попробуйте заменить «
nonlocal x
» на «
global x
», а затем удалить это за- резервированное слово, и пронаблюдайте за разницей между этими двумя случаями.
10.4. Зарезервированное слово «nonlocal»
68
A Byte of Python (Russian), Версия 2.02 10.5 Значения аргументов по умолчанию
Зачастую часть параметров функций могут быть необязательными, и для них будут ис- пользоваться некоторые заданные значения по умолчанию, если пользователь не укажет собственных. Этого можно достичь с помощью значений аргументов по умолчанию. Их можно указать, добавив к имени параметра в определении функции оператор присваи- вания (
=
) с последующим значением.
Обратите внимание, что значение по умолчанию должно быть константой. Или точнее говоря, оно должно быть неизменным
1
– это объясняется подробнее в последующих гла- вах. А пока запомните это.
1 2 3 4 5 6 7 8 9 ... 14
Пример: (сохраните как func_default.py
)
def
say
(message, times
=
1
):
(message
*
times)
say(
'Привет'
)
say(
'Мир'
,
5
)
Вывод:
$ python func_default.py
Привет
МирМирМирМирМир
Как это работает:
Функция под именем say используется для вывода на экран строки указанное число раз. Если мы не указываем значения, по умолчанию строка выводится один раз. Мы достигаем этого указанием значения аргумента по умолчанию,
равного
1
для параметра times
2
При первом вызове say мы указываем только строку, и функция выводит её
один раз. При втором вызове say мы указываем также и аргумент
5
, обозначая таким образом, что мы хотим сказать
3
фразу 5 раз.
Важно: Значениями по умолчанию могут быть снабжены только параметры, находящи- еся в конце списка параметров. Таким образом, в списке параметров функции параметр со значением по умолчанию не может предшествовать параметру без значения по умол- чанию. Это связано с тем, что значения присваиваются параметрам в соответствии с их положением. Например,
def func(a, b=5)
допустимо, а def func(a=5, b)
– не допустимо.
1
«immutable» в терминологии Python (прим. перев.)
2
times – англ. «раз» (прим. перев.)
3
say – англ. «сказать» (прим. перев.)
10.5. Значения аргументов по умолчанию
69
A Byte of Python (Russian), Версия 2.02 10.6 Ключевые аргументы
Если имеется некоторая функция с большим числом параметров, и при её вызове тре- буется указать только некоторые из них, значения этих параметров могут задаваться по их имени – это называется ключевые параметры. В этом случае для передачи аргументов функции используется имя (ключ) вместо позиции (как было до сих пор).
Есть два преимущества такого подхода: во-первых, использование функции становится легче, поскольку нет необходимости отслеживать порядок аргументов; во-вторых, можно задавать значения только некоторым избранным аргументам, при условии, что осталь- ные параметры имеют значения аргумента по умолчанию.
Пример: (сохраните как func_key.py
)
def
func
(a, b
=
5
, c
=
10
):
(
'a равно'
, a,
', b равно'
, b,
', а c равно'
, c)
func(
3
,
7
)
func(
25
, c
=
24
)
func(c
=
50
, a
=
100
)
Вывод:
$ python func_key.py a равно 3, b равно 7, а c равно 10
a равно 25, b равно 5, а c равно 24
a равно 100, b равно 5, а c равно 50
Как это работает:
Функция с именем func имеет один параметр без значения по умолчанию, за которым следуют два параметра со значениями по умолчанию.
При первом вызове,
func(3, 7)
, параметр a
получает значение
3
, параметр b
получает значение
7
, а c
получает своё значение по умолчанию, равное
10
При втором вызове func(25, c=24)
переменная a
получает значение 25 в силу позиции аргумента. После этого параметр c
получает значение
24
по имени, т.е. как ключевой параметр. Переменная b
получает значение по умол- чанию, равное
5
При третьем обращении func(c=50, a=100)
мы используем ключевые аргу- менты для всех указанных значений. Обратите внимание на то, что мы ука- зываем значение для параметра c
перед значением для a
, даже несмотря на то, что в определении функции параметр a
указан раньше c
10.6. Ключевые аргументы
70