Области видимости, вложенные функции

Области видимости, вложенные функции

Некоторые возможности работы с функциями в языке программирования python

Вложенные функции

Вложенные функции (внутренние функции) – функции, которые определены внутри других функций.

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

Вложенная функция - это просто функция внутри другой функции, и ее иногда называют "внутренней функцией".

def [имя функции] ( [аргументы] ):

[тело функции]

def [имя вложенной функции] ( [аргументы] ):

[тело вложенной функции]

При работе с функциями иногда возникает необходимость объявить одну функцию внутри другой. Такие функции называются вложенными

Вложенные функции

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

def outer (): # внешняя функция print ( "it is outer" ) def inner (): # внутренняя функция print ( "it is inner" )

it is outer

inner() # вызов внутренней функции outer() # запуск внешней функции # inner() # внутреннюю функцию здесь запустить не выйдет

it is inner

В Python понятие объекта является ключевым. Они везде! Фактически все, что программа Python создает или с чем работает, — это объект.

Выражение присваивания создает символическое имя, которое вы можете использовать для ссылки на объект. Так выражение x = 'foo' создает символическое имя x, которое ссылается на строковый объект 'foo'.

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

Существует 4 типа пространств имен:

• Встроенное.
• Глобальное.
• Объемлющее.
• Локальное.

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

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

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

Глобальное пространство имен

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

Локальное и объемлющее пространства имен

Интерпретатор создает новое пространство имен при каждом выполнении функции. Это пространство является локальным для функции и сохраняется до момента завершения ее действия.

Выделяют две основные области видимости:

• глобальная – переменная доступна во всей программе (и в ее функциях)
• локальная – только в той функции, где переменная определена

Теперь стоит поговорить о таком понятии, как область видимости переменной

Python будет искать его следующих областях видимости в таком порядке:

• Локальная. Если вы ссылаетесь на x внутри функции, то интерпретатор сначала ищет его в самой внутренней области, локальной для этой функции.
• Объемлющая . Если x не находится в локальной области, но появляется в функции, располагающейся внутри другой функции, то интерпретатор ищет его в области видимости объемлющей функции.
• Глобальная. Если ни один из вышеуказанных вариантов не принес результатов, то интерпретатор продолжит поиск в глобальной области видимости.
• Встроенная . Если интерпретатор не может найти x где-либо еще, то он направляет поиски во встроенную область видимости.

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

Если переменная определена вне функций – она глобальная и доступна во всех функциях

name = "Ezio" # глобальная переменная, определена вне функций def Hi (): print ( "Hi" , name) # функция использует глобальную переменную def Hello (): print ( "Hello" , name) Hi() # вызов функций Hello()

Hi Ezio

Hello Ezio

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

Локальная переменная доступна только в той функции, в которой она определена

def Hi (): name = "Ezio" # локальная переменная функции Hi print ( "Hi" , name) # функция использует локальную переменную def Hello (): name = "Altair" # дрругая локальная переменная (имя переменной может повторяться в разных контекстах) print ( "Hello" , name) Hi() # вызов функций Hello()

Hi Ezio

Hello Altair

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

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

name = "Altair" # глобальная переменная def Hi (): name = "Ezio" # локальная переменная скрывает глобальную print ( "Hi" , name) # функция использует локальную переменную def Hello (): print ( "Hello" , name) # а здесь используется глобальная Hi() # вызов функций Hello()

Hi Ezio

Hello Altair

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

Ключевое слово global в функции позволяет обращаться к глобальной переменной и менять ее значение

name = "Altair" # глобальная переменная def Hi (): global name # обращаемся к глобальной переменной name = "Ezio" # можем изменить значение глобальной переменной print ( "Hi" , name) def Hello (): print ( "Hello" , name) # а здесь используется глобальная Hello() # имя еще не изменили Hi() # функция HI меняет глобальную переменную с именем Hello() # теперь у глобальной переменной новое значение

Hello Altair

Hi Ezio

Hello Ezio

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

При этом у вложенных функций могут быть свои локальные переменные

temp = 0 # глобальная переменная def outer (): temp = 23 # локальная (для outer) def inner (): temp = - 10 # локальная (для inner) print (temp) inner() print (temp) outer() # печать двух разных локальных temp print (temp) # и печать глобальной temp

-10

23

0

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

Если во вложенной функции необходимо использовать локальную переменную внешней функции – используется ключевое слово nonlocal

temp = 0 # глобальная переменная def outer (): temp = 23 # локальная (для outer) def inner (): nonlocal temp # будет использоваться локальная переменная внешней функции temp = - 10 # изменяем внешнюю локальную переменную print (temp) inner() print (temp) outer() # печать двух локальных переменных print (temp) # и печать глобальной temp

-10

-10

0

Замыкания

Замыкания – это функции, которая запоминает свое окружение (состояние внешней функции) даже если она выполняется вне своей области видимости.

Для этого необходимо:

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

Замыкания

Например, функция inner запоминает состояние внешнего окружения (переменную n функции power) и использует в расчетах

def power (n): # внешняя функция с переменной n def inner (m): # внутренняя функция return n ** m # использование окружения (n) return inner # power возвращает внутреннюю функцию fn = power( 10 ) # fn = inner() print (fn( 3 )) # возведение 10 в степени разных чисел print (fn( 4 )) print (fn( 5 ))

1000

10000

100000

Декораторы

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

def [имя декоратора] ( [имя функции] ):

[тело декоратора]

return [модифицированная функция]

@ [имя декоратора]

def [имя исходной функции] ( [аргументы] ):

[тело исходной функции]

Декораторы

Например, декоратор может добавить к исходной функции дополнительный функционал

def select (input_func): # определение функции декоратора def output_func (): # определяем функцию, которая будет выполняться вместо оригинальной print ( "Hello" ) # модификация оригинальной функции input_func() # вызов оригинальной функции return output_func # возвращаем новую функцию @select # применение декоратора select def hello (): # определение оригинальной функции print ( "World" ) # содержимое оригинальной функции hello() # вызов оригинальной функции

Hello

World

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

data = [ 1 , 2 , 3 , 4 , 5 ] setFuncs(data , lambda a: a** 2 , lambda a: a** 3 )

def setFuncs (data , firstFunc , secondFunc): for i in data: if (i% 2 == 0 ): print (firstFunc(i)) else : print (secondFunc(i)) data = [ 1 , 2 , 3 , 4 , 5 ] setFuncs(data , lambda a: a** 2 , lambda a: a** 3 )

1 ): story(names[ 1 :]) story([ "jack" , "john" , "james" ])" width="640"

Пример 2. Создайте функцию story для вывода всех имен из списка (который передается как аргумент). При создании функции вместо цикла нужно использовать рекурсию (то есть вызывать функцию из нее же).

story([ "jack" , "john" , "james" ])

hello, jack

hello, john

hello, james

def story (names): print ( "hello," , names[ 0 ]) if ( len (names) 1 ): story(names[ 1 :]) story([ "jack" , "john" , "james" ])

Пример 3. Создайте функцию showStars, которая получает список чисел и выводит такое же количество звездочек в строку (через пробел), то есть при вводе 2 3 5 на выход должны вывестись ** *** *****. Вывод указанного количества звездочек реализуйте в качестве внутренней функции.

showStars([ 2 , 4 , 6 , 8 , 10 ])

** **** ****** ******** **********

def showStars (data): def stars (n): return (n * "*" ) text= "" for i in data: text = text + stars(i) + " " print (text) showStars([ 2 , 4 , 6 , 8 , 10 ])

Пример 4. Создайте программу с глобальной переменной temp (температура в помещении) и двумя функциями для heat и cold (нагрев и охлаждение). Обе функции принимают значение времени (time) и имеют свои (различные) коэффициенты эффективности (coef), при этом первая увеличивает температуру на time*coef, а вторая уменьшает. Проверьте работу вашей программы.

print(temp)

heat(2)

print(temp)

cold(2)

print(temp)

temp= 20 def heat (time): coef = 2 global temp temp += coef * time def cold (time): coef = 5 global temp temp -= coef * time print (temp) heat( 2 ) print (temp) cold( 2 ) print (temp)

Пример 4

temp= 20 def heat (time): coef = 2 global temp temp += coef * time def cold (time): coef = 5 global temp temp -= coef * time print (temp) heat( 2 ) print (temp) cold( 2 ) print (temp)

Задача 1. Создайте функцию calc, которой можно передать символ + - * /, а функция должна вернуть соответствующую функцию, то есть при, вызове func("+") мы должны получить функцию, которая складывает два числа. Для проверки присвойте двум переменным результат созданной вами функции (например, для * и для /) и проверьте работу этих переменных на разных парах чисел.

mul = calc( "*" ) div = calc( "/" ) print (mul( 10 , 2 )) print (div( 10 , 2 ))

def calc (operation): ?????????????? mul = calc( "*" ) div = calc( "/" ) print (mul( 10 , 2 )) print (div( 10 , 2 ))

Задача 2. Необходимо создать функцию changeRange, которая принимает два числа (start и end) и функцию operation. В ней над всеми элементами ряда от start до end необходимо совершить operation. Функция должна вернуть сумму всех чисел от start до end, применив переданную ей операцию. Проверьте функцию, передав ей два числа и лямбда функцию (например, умножения на 10)

print (changeRange( 1 , 2 , lambda a: a* 10 ))

def changeRange (start , end , operation): ??????????????? return (sum) print (changeRange( 1 , 2 , lambda a: a* 10 ))

Задания для самостоятельного решения

• Напишите рекурсивную функцию factorial(n), которая будет принимать положительное целое число n и возвращать факториал от этого числа (1 x 2 x 3 x … x n).
• Напишите рекурсивную функцию summation(n), которая будет принимать положительное целое число n и возвращать сумму чисел от 1 до n.
• Напишите рекурсивную функцию sum_odd(lis), которая будет принимать список из целых чисел и возвращать сумму только нечётных чисел из списка.
• Напишите рекурсивную функцию sum_sub(list), которая будет принимать список целых чисел. Эта функция будет суммировать все нечётные числа и вычитать все чётные числа. В конце она будет возвращать получившееся значение.
• Слова-палиндромы — это строки, которые одинаково читаются с обеих сторон. Например: «aba», «abba», «abcba», «aaa», «ababa» и так далее.
• Напишите функцию is_palindrome(string), которая будет принимать строку и возвращать «True», если строка является палиндромом, и «False» во всех других случаях.
• Напишите рекурсивную функцию fib(n), которая будет принимать положительное целое число n и возвращать n-ое число Фибоначчи.
• Числа Фибоначчи — это серия чисел, которая начинается с 0 и 1. Каждое последующее число будет являться суммой двух предыдущих чисел.