Быстрая навигация:
1.31 Списки - массивы. Первое знакомство. 1.30 Функции которые возвращают результат - return 1.29 Подпрограммы: функции и процедуры в Питоне 1.28 Преобразование типов данных - int() 1.27 Ввод данных с клавиатуры - input() 1.26 Типы и размеры данных 1.25 Цикл с предусловием - while. Числа Фибоначчи 1.24 Измерение длины строки, списки 1.23 Срезы строк - вывод определенного количества символов из имеющегося текста 1.22 Строки и управляющие символы 1.21 Системные ошибки в процессе отладки программы 1.20 Оператор ветвления - if, комментарии 1.19 Вывод на печать - print(), быстрый ввод данных, округление, комментарии 1.18 Типы программирования. Часть 2. Объектно-ориентированное программирование 1.17 Типы программирования. Часть 1. Структурное программирование. Циклы 1.16 Представление символьной информации - ASCII 1.15 Деление двоичных чисел 1.14 Математические операции с двоичными числами 1.13 Как хранится и записывается информация. Биты и байты 1.12 Перевод целых чисел десятичной системы счисления в другую систему 1.11 Перевод целых чисел из шестнадцатеричной системы счисления в десятичную 1.10 Перевод целого двоичного числа в шестнадцатеричное 1.9 Перевод целого двоичного числа в другую систему счисления 1.8 Системы счисления 1.7 Булевая алгебра. Логические выражения 1.6 Базовые понятия. Часть 3 - Числа, выражения, операнды, знаки операций 1.5 Базовые понятия. Часть 2 - Программа, данные 1.4 Базовые понятия. Часть 1 - Задача и алгоритм 1.3 Среда разработки СИ 1.2 История языков программирования 1.1 Введение

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

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

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

Как это выглядит на практике?
К примеру в какой то очень большой программе вам необходимо произвести (мы с вами уже рассматривали алгоритм его работы).
И вместо того, чтобы в этом большом программном коде каждый раз писать еще и код для расчета чисел Фибоначчи, мы просто выносим его в отдельный файл. Это и будет подпрограмма.
Тогда в том месте где должен производиться необходимый расчет этих чисел мы вставляем лишь некое указание на то, чтобы в этом месте была вызвана наша подпрограмма.

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

В разных языках программирования такие подпрограммы называются:

Процедурами или
- функциями

В языке СИ такие подпрограммы называются функциями.

Кстати мы с вами уже применяли функции на практике!
Например мы с вами использовали ВСТРОЕННЫЕ в интерпретатор функции:

Print() - для вывода данных на печать неких параметров, которые были заключены в круглые скобки
- str() - для преобразования данных к строковому типу. Именно ее предварительно запускает функция print()
- int() - для преобразования данных к целому числу
- float() - для преобразования целых чисел в дробный тип
- round() - для округления некоего значения
и т.п.

Итак.
Для вызова функции достаточно набрать ее имя и в скобках перечислить требуемые параметры (аргументы) которые мы хотим передать в данную функцию.

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

def ИМЯ_ФУНКЦИИ(СПИСОК_ПАРАМЕТРОВ):
ПОСЛЕДОВАТЕЛЬНОСТЬ_ВЫРАЖЕНИЙ

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

В Питоне для определения функции первым параметром пишется служебное слово def (заголовок функции) (от define - определить) - этим мы указываем, что будем вызывать функцию.
Заголовок функции после закрывающей круглой скобки заканчивается двоеточием (в Питоне) и далее следуют необходимые выражения начинающиеся со смещения относительно начала строки (используется как правило клавиша TAB).

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

Def fib(n): a, b = 0, 1 while a < n: print(a, end = " ") a, b = b, a + b print()

Если вкратце, то строка:
a, b = 0, 1
означает запись (но не полностью эквивалентна ей):
a = 0 b = 1

А строка
a, b = b, a + b
означает запись:
a = b b = a + b

Рассмотрим код по строкам:

1
def fib(n):
- определить (def ) функцию по имени fib с параметрами (аргументами) указанными в круглых скобках которые мы хотим передать в эту самую функцию по имени fib .
Т.е. в качестве параметра n мы будем передавать значение для которого будет производиться расчет. Это число будет передаваться в нашу функцию в качестве аргумента.

После двоеточия вводимые данные в интерпретаторе Python печатаются с отступом. Это говорит о том, что эти данные имеют непосредственное отношение к данной функции.

2
a, b = 0, 1
Инициализируем переменные соответствующими значениями:
a = 0 b = 1

3
while a < n:
Оператор цикла while - будет выполняться до тех пор, пока будет выполнено условие цикла a
Здесь также после двоеточия открывается новый блок имеющий НЕПОСРЕДСТВЕННОЕ отношение только к циклу.
Этот блок будет печататься после перевода строки с дополнительным отступом.

4
print(a, end = " ")
Выводим на печать данные переменной а и пробел после каждого витка цикла

5
a, b = b, a + b
Присваиваем переменным соответствующие значения:
a = b b = a + b
Для изменения исходных данных и продолжения работы расчета чисел Фибоначчи

6
print()

Обратите внимание на то, что данный print() нужно печатать ПОД while ... т.е. он уже относится не к телу цикла while , а к телу функции fib
Однако для чего нам нужен второй print() да еще и с пустыми скобками?

В данном случае это вывод пустой строки - сделать "отбивку" - перенос строки. А еще вернее, данная функция выводит на печать символ перевода строки.
В нашем случае можно и не использовать.

Итак мы определили функцию fib для расчета чисел Фибоначчи и она, как вы заметили - не работает.

Для того, чтобы она заработала необходимо ее ВЫЗВАТЬ и передать ей некий параметр для расчетов.
Вызываем нашу функцию и передаем в качестве аргумента значение 40 .
В результате мы должны получить расчет чисел Фибоначчи для всех чисел до 40 :

Печатаем в интерпретаторе Python:
fib(40)
Получаем:

0 1 1 2 3 5 8 13 21 34

Вы можете еще раз вызвать функцию fib() с другим параметром и точно также получите вывод необходимых данных.
Например введем
fib(400)
И получим:

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

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

Во многих языках программирования процедура и функция не синонимы и имеют отличия друг от друга.
Чем же они отличаются друг от друга в таких языках программирования?

Функция - возвращает значение
- Процедура - не возвращает значение

Поясним на примере:

Если мы можем использовать такую запись (только в качестве примера):
x = fib(n) - то это функция, она присваивает полученное значение переменной x (в данном случае переменной x ничего записано не будет)

Если же возможна только запись fib(n) - то это процедура.

Таким образом мы можем сказать, что наш пример является ПРОЦЕДУРОЙ.

Как в Питоне использовать наш код для расчета чисел Фибоначчи в качестве функции мы рассмотрим несколько позже...

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

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

• print() выводит объект в терминал.
• int() преобразовывает строки или числа в целые числа.
• len() возвращает длину объекта.

Имя функции содержит круглые скобки и может содержать параметры.

Данное руководство научит вас определять пользовательские функции.

Определение функции

Для начала попробуйте преобразовать простую программу «Hello, World!» в функцию.

Создайте новый текстовый файл hello.py, а затем определите функцию.

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

Чтобы определить функцию hello(), добавьте в файл hello.py:

Это исходное определение функции.

def hello():
print("Hello, World!")

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

После определения функции вызовите её:

def hello():
print("Hello, World!")
hello()

Теперь запустите программу:

Она должна вернуть:

Функция hello() – довольно простой пример. Функции могут быть гораздо сложнее: содержать циклы for, условные выражения и другие компоненты.

Достигая оператора return, функция прекращает выполнение.

# Файл return_loop.py
def loop_five():
for x in range(0, 25):
print(x)
if x == 5:
# Stop function at x == 5
return
print("This line will not execute.")
loop_five()

Оператор return в цикле for прекращает выполнение функции, потому строки после функции не будут запущены. Если бы вместо него использовался оператор break, программа прекратила бы выполнение цикла, а не функции, и последнее выражение print() было бы обработано.

Функция main()

В языке Python функцию можно вызвать в конце программы, и она запустится (как показано в предыдущих примерах), однако некоторым языкам программирования (например, C++ или Java) требуется функция main. Функция main() в Python необязательна, но она позволяет логически структурировать программу Python и объединить наиболее важные её компоненты в одну функцию. Также с её помощью программы Python легче читать программистам, которые работают с другими языками.

Вернитесь в файл hello.py и добавьте функцию main(), сохранив при этом функцию hello().

def hello():
print("Hello, World!")
def main():

В функцию main() добавьте выражение print(). Затем вызовите функцию hello() внутри функции main().

def hello():
print("Hello, World!")
def main():
print("This is the main function")
hello()

В конце файла вызовите функцию main().

def hello():
print("Hello, World!")
def main():
print("This is the main function.")
hello()
main()

Теперь можно запустить программу:

python hello.py
This is the main function.
Hello, World!

Теперь попробуйте использовать несколько функций.

27 января 2009 в 14:49

Основы Python - кратко. Часть 6. Расширенное определение функций.

• Python

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

Параметры по-умолчанию

Для всех параметров функций можно указывать значения по-умолчанию, это дает возможность вызвать функцию с меньшим числом параметров. Например, у нас есть функция для авторизации пользователя на сайте:
def login(username="anonymous", password=None): """Тут какие-то действия""" pass # вызвать эу функцию мы можем одним # из нижеприведенных способов login("root", "ujdyzysqgfhjkm") login("guest") login() # мы можем указать какой из параметров мы передаем, # указав его имя в явном виде login(password="[email protected]")

В общем, те параметры что есть – сопоставляются слева направо (если имя не указано конкретно), остальные заменяются значениями по-умолчанию (если они конечно заданы).
Важной особенностью в данном случае является то, что значения по-умолчанию вычисляются и ассоциируются только один раз – в момент объявления функции. Все вытекающие из этого недостатки наглядно продемонстрирует пример:
def_val = 2 def our_func(val = def_val): print val our_func(4) # выведет 4 our_func() # выведет 2 – значение по-умолчанию def_val = 12 our_func() # все равно 2, так как def_val было равно 2 на момент объявления
Более неприятное следствие из этого. Допустим, мы хотим объявить функцию, принимающую на вход список, что-то с ним делающую и печатающую его. Причем если список не задан, то по умолчанию он равен пустому.
Попытка сделать это «в лоб» будет работать не совсем так как хотелось бы:
In : def lister(lst = ): ...: lst.append() ...: print lst ...: In : lister() [] In : lister() [, ] In : lister() [, , ]
Собственно, проблема тут в том, что переменная lst будет ассоциирована с пустым списком один раз, и между вызовами будет сохранять свое значение.
В данном случае, правильно будет описать нашу функцию следующим образом (как рекомендуют все учебники):
In : def lister2(lst=None): ...: if lst is None: ...: lst= ...: lst.append() ...: print lst ...: In : lister2() [] In : lister2() [] In : lister2() ]
Данная функция как раз будет работать так как хотелось бы изначально.

Position и keyword аргументы.

Зачастую случается необходимость сделать функцию, которая обрабатывает неопределенное число параметров. Например функция расчета суммы элементов списка.
Мы конечно можем передавать все аргументы как один параметр типа list, но это выглядит некрасиво. Потому в Пайтоне был придуман специальный механизм, называемый position-arguments. Вот пример, демонстрирующий использование.
In : def list_sum(*args): ...: smm = 0 ...: for arg in args: ...: smm += arg ...: return smm ...: In : list_sum(1, 2, 3) Out: 6 In : list_sum(1) Out: 1 In : list_sum() Out: 0
В данном случае, все наши параметры «упаковываются» в список args в соответствии с их «порядковым номером» при передаче.
Возможна и обратная операция, допустим у нас есть список значений, и мы хотим передать их как список параметров функции:
In : lst = In : list(range(*lst)) Out:
В этом примере список lst был «распакован» и подставлен на место параметров функции range, то есть вызов был аналогичен:
In : list(range(1, 10, 2)) Out:
Кроме position, можно использовать и т.н. keyword аргументы. Они отличаются тем что для них надо явно задавать имя. Вот пример – функция, генерирующая insert выражение для базы данных (NB: максимальная оптимизация не ставилась в данном случае за самоцель).
def enquote1(in_str): """Quotes input string with single-quote""" in_str = in_str.replace(""", r"\"") return ""%s"" % in_str def enquote2(in_str): """Quotes input string with double-quote""" in_str = in_str.replace(""", r"\"") return ""%s"" % in_str def gen_insert(table, **kwargs): """Generates DB insert statement""" cols = vals = for col, val in kwargs.items(): cols.append(enquote2(col)) vals.append(enquote1(str(val))) cols = ", ".join(cols) vals = ", ".join(vals) return "INSERT INTO "%s"(%s) VALUES(%s);" % (table, cols, vals) print gen_insert("workers", name="John", age=21, salary=1500.0) params = {"name": "Mary", "age": 19, "salary": 1200.0} print gen_insert("workers", **params)
На выходе мы получим то что и ожидалось:
INSERT INTO "workers"("salary", "age", "name") VALUES("1500.0", "21", "John"); INSERT INTO "workers"("salary", "age", "name") VALUES("1200.0", "19", "Mary");
Обратите внимание на второй вызов функции gen_insert – так мы можем вызвать функцию имея только словарь параметров. Это применимо к любой функции. Так же возможны различные сочетания positional и keyword аргументов.

В качестве завершающего примера рассмотрим такую функцию:
def logging(func, *args, **kwargs): res = func(*args, **kwargs) print "calling %s, returned %r" % (func.__name__, res) return res def double(x): "Doubles a number" return 2*x print logging(double, 155)
Это – простейший способ отладки функции, мы как бы «оборачиваем» вызов одной функции другой что бы вывести промежуточную информацию.
Забегая вперед – скажу что в Пайтоне есть очень мощный инструмент для более удобного использования подобного рода «оборачивающих» функций, называемый декораторами, но про это позже.

На этом на сегодня все. Продолжение следует (либо мое, либо уважаемого

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

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

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

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

Как написать первую функцию

В Python 3 для начинающих свое знакомство с программированием есть самая простая функция print(). Чтобы увидеть ее в действии вам понадобится среда разработки. Для этого скачайте дистрибутив языка с официального сайта и установите Python на компьютер.

Откройте меню «Пуск» и в списке программ найдите Python 3. Разверните его щелчком левой клавиши. В открывшемся списке найдите среду IDLE и запустите ее. Наберите print(«Hello, World!») и нажмите «Ввод». Интерпретатор вернет результат вашей первой функции.

Некоторые программисты предпочитают работать в консоли. Если вы относитесь к их числу, нажмите win+R и введите команду python.exe. Откроется обычный интерпретатор, только с интерфейсом cmd. Наберите программу описанным выше образом и нажмите Enter в конце, чтобы увидеть результат.

Как использовать def

Новые функции создаются с помощью инструкции def. Они так же эффективны, как и встроенные print() или open(), но отличаются от функций в компилирующих языках. Python def относится к исполняемым инструкциям. Это означает, что функции не существует, пока интерпретатор ее не увидит, и не перейдет к ее исполнению.

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

Теперь давайте напишем функцию, возвращающую фразу «Hello, World!», только с использованием def:

• >>> def здравствуй_мир():
• print(«Hello, World!»)
• >>> здравствуй_мир() #вызов функции
• Hello, World!

Синтаксис функций и return

Инструкция def в Python состоит из заголовка и пишется по следующим правилам:

• >>>def <имя>

После заголовка следует блок инструкций, который начинается с обязательного отступа. В IDLE интерпретатор сделает его автоматически. Но в блокноте или другом текстовом редакторе вы можете забыть нажать Tab. Тогда функция не запустится. Программный код в блоке инструкции называется телом функции и выполняется каждый раз при ее вызове.

Также в теле иногда находится return:

• def <имя>(аргумент 1, аргумент 2, аргумент N):
• return <значение>

Return завершает работу функции и передает вызывающей программе объект-результат. Инструкция не является обязательной. Функция будет работать без return, и завершится, когда поток управления достигнет конца ее тела.

Параметры и аргументы

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

Аргументы внутри функции никак не связаны с объектами вне ее, поэтому в программировании их относят к локальным переменным. Область видимости ограничена блоком функции, который начинается с def и заканчивается return. Чтобы было понятнее, приведем пример:

• x = 12 #присваиваем переменным ссылки на целочисленные объекты
• y = 34
• >>>def example(x,y): #создаем функцию с именем example
• x = «Hello» #присваиваем значения аргументам x, y
• y = «Python»
• print(x, y, sep= «, »)
• return None
• >>>example(x, y) #вызываем функцию, не забыв указать параметры
• Hello, Python
• >>>print(x, y)
• 12 34

Обратите внимание на предпоследнюю строчку кода. В интерпретаторе Python команда print() вернула переменные x и y из глобальной области видимости.

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

• >>>def E_2(x, y):
• return x + y
• >>>E_2(«Hello, » «Python!») #чтобы слова были разделены, поставьте пробел перед закрывающей кавычкой
• Hello, Python!
• E_2(5, 4)

Как видно из примера с простой функцией E_2, результат полностью зависит от типа объектов x и y. В первом случае E_2 выполнила конкатенацию, а во втором - арифметическую операцию сложения. В этом заключается принцип полиморфизма и То, что объекты определяют синтаксический смысл, обуславливает гибкость и простоту языка. Не нужно тратить время на то, чтобы отдельно указать тип данных, с которым работает функция.

Правило LEGB

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

Правило LEGB объясняет схему разрешения имен:

1. Как только интерпретатор находит переменную внутри инструкции def, он сначала выполняет поиск значений в локальной области видимости.
2. Если поиск не дает результата, он переходит к области видимости любой всеобъемлющей инструкции def.
3. Дальше интерпретатор двигается к глобальным именам в верхнем уровне модуля и тем, что обозначены как global.
4. Если поиск не дает результатов, интерпретатор ищет имена во встроенной области видимости языка Python.

Рассмотрим наглядный пример:

• >>>L = 85
• >>>R = 23
• >>>def пример_2(K):
• R = 10
• C = L + K+R
• return C
• >>>пример_2(5)

Переменные L и R находятся на верхнем уровне и являются глобальными именами. R, C и K - это локальные переменные, так как присваивание значения происходит внутри инструкции def.

Интерпретатор сначала выполняет операцию сложения для локальных R, C и K, игнорируя переменную R вне инструкции def. Потом ищет L, и не найдя ее среди имен local, переходит на верхний уровень.

Что такое lambda

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

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

Основы лямбда-выражений

По внешнему виду lambda-выражения напоминают инструкции def. Вначале пишется ключевое слово lambda, потом аргументы, двоеточие и само выражение:

• >>>f = lambda x, y, z: x + y + z
• >>>f(2, 3, 4)

Тело лямбда представляет собой одно единственное выражение, а не блок инструкций. За счет этого lambda ограничена в возможностях и не настолько универсальна как def. В ней может быть реализована только логика, без циклов while или for.

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

Lambda-выражения очень удобно встраивать в программу. За счет небольшого размера они минимизируют и упрощают код. Но использование лямбда не является принципиальным. В Python 3 начинающим для работы будет достаточно инструкции def.

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

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

# -*- coding: utf-8 -*- Phones = ["Nokia", "Samsung", "LG", "Sony"] def show_as_text(user_list): words = "" for value in user_list: words += str(value) + " " return words print "Phones: ", show_as_text(Phones) # Вернет: Phones: Nokia Samsung LG Sony

Достаточно простая структура функции. Название функции show_as_text, важно чтобы не совпадала с названием функции самого Python. Имя функции должна быть уникальна и по сравнению с переменными. Если функция будет иметь название get_values, и после нее в скрипте будет создана переменная с тем же именем, тогда вызов get_values(args) выдаст ошибку.

# -*- coding: utf-8 -*- def get_value(): return True a = 1 b = 3 get_value = "some text..." is_true = get_value()

Получим ошибку:

TypeError: "str" object is not callable Если потребуется вернуть из функции несколько значений, можно использовать кортеж. Создадим небольшой аналог игры Бинго! чтобы получить разные номера. # -*- coding: utf-8 -*- import random def bingo(): return (random.randint(0, 30), random.randint(0, 30), random.randint(0, 30)) Numbers = bingo() print "Первый: ", Numbers print "Второй: ", Numbers print "Третий: ", Numbers

Присвоить аргументу функции значение по умолчанию можно с помощью оператора присваивания.

Def connect(ip, port=8080): return str(ip) + " " + str(port) print connect("127.0.0.1") # Получим: 127.0.0.1 8080

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

Connect("сайт", 80)

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

Connect(port=80, host="сайт")

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

Num = 1 # Глабальная перемення def next_number(): global num personal_num = 999 num += 1 return num print next_number() # результат 2 # Попробуем получить значении локальной переменной personal_num print personal_num # Ошибка NameError: name "personal_num" is not defined