Что выведет следующий код var 10 print var

Что выведет следующий код var 10 print var

Напомним, что в математике факториал числа n определяется как Например, Ясно, что факториал можно легко посчитать, воспользовавшись циклом for. Представим, что нам нужно в нашей программе вычислять факториал разных чисел несколько раз (или в разных местах кода). Конечно, можно написать вычисление факториала один раз, а затем используя Copy-Paste вставить его везде, где это будет нужно.

# вычислим 3! res = 1 for i in range(1, 4): res *= i print(res) # вычислим 5! res = 1 for i in range(1, 6): res *= i print(res)

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

Функции — это такие участки кода, которые изолированы от остальный программы и выполняются только тогда, когда вызываются. Вы уже встречались с функциями sqrt(), len() и print(). Они все обладают общим свойством: они могут принимать параметры (ноль, один или несколько), и они могут возвращать значение (хотя могут и не возвращать). Например, функция sqrt() принимает один параметр и возвращает значение (корень числа). Функция print() принимает переменное число параметров и ничего не возвращает.

Покажем, как написать функцию factorial(), которая принимает один параметр — число, и возвращает значение — факториал этого числа.

def factorial(n): res = 1 for i in range(1, n + 1): res *= i return res print(factorial(3)) print(factorial(5))

Дадим несколько объяснений. Во-первых, код функции должен размещаться в начале программы, вернее, до того места, где мы захотим воспользоваться функцией factorial(). Первая строчка этого примера является описанием нашей функции. factorial — идентификатор, то есть имя нашей функции. После идентификатора в круглых скобках идет список параметров, которые получает наша функция. Список состоит из перечисленных через запятую идентификаторов параметров. В нашем случае список состоит из одной величины n. В конце строки ставится двоеточие.

Далее идет тело функции, оформленное в виде блока, то есть с отступом. Внутри функции вычисляется значение факториала числа n и оно сохраняется в переменной res. Функция завершается инструкцией return res, которая завершает работу функции и возвращает значение переменной res.

Инструкция return может встречаться в произвольном месте функции, ее исполнение завершает работу функции и возвращает указанное значение в место вызова. Если функция не возвращает значения, то инструкция return используется без возвращаемого значения. В функциях, которым не нужно возвращать значения, инструкция return может отсутствовать.

Приведём ещё один пример. Напишем функцию max(), которая принимает два числа и возвращает максимальное из них (на самом деле, такая функция уже встроена в Питон).

10 20

def max(a, b): if a > b: return a else: return b print(max(3, 5)) print(max(5, 3)) print(max(int(input()), int(input())))

Теперь можно написать функцию max3(), которая принимает три числа и возвращает максимальное их них.

def max(a, b): if a > b: return a else: return b def max3(a, b, c): return max(max(a, b), c) print(max3(3, 5, 4))

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

def max(*a): res = a[0] for val in a[1:]: if val > res: res = val return res print(max(3, 5, 4))

Все переданные в эту функцию параметры соберутся в один кортеж с именем a, на что указывает звёздочка в строке объявления функции.

2. Локальные и глобальные переменные

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

def f(): print(a) a = 1 f()

Здесь переменной a присваивается значение 1, и функция f() печатает это значение, несмотря на то, что до объявления функции f эта переменная не инициализируется. В момент вызова функции f() переменной a уже присвоено значение, поэтому функция f() может вывести его на экран.

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

Но если инициализировать какую-то переменную внутри функции, использовать эту переменную вне функции не удастся. Например:

def f(): a = 1 f() print(a)

Получим ошибку NameError: name ‘a’ is not defined . Такие переменные, объявленные внутри функции, называются локальными. Эти переменные становятся недоступными после выхода из функции.

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

def f(): a = 1 print(a) a = 0 f() print(a)

Будут выведены числа 1 и 0. Несмотря на то, что значение переменной a изменилось внутри функции, вне функции оно осталось прежним! Это сделано в целях “защиты” глобальных переменных от случайного изменения из функции. Например, если функция будет вызвана из цикла по переменной i , а в этой функции будет использована переменная i также для организации цикла, то эти переменные должны быть различными. Если вы не поняли последнее предложение, то посмотрите на следующий код и подумайте, как бы он работал, если бы внутри функции изменялась переменная i.

def factorial(n): res = 1 for i in range(1, n + 1): res *= i return res for i in range(1, 6): print(i, '! = ', factorial(i), sep='')

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

5! = 1 5! = 2 5! = 6 5! = 24 5! = 120

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

Более формально: интерпретатор Питон считает переменную локальной для данной функции, если в её коде есть хотя бы одна инструкция, модифицирующая значение переменной, то эта переменная считается локальной и не может быть использована до инициализации. Инструкция, модифицирующая значение переменной — это операторы = , += , а также использование переменной в качестве параметра цикла for . При этом даже если инструкция, модицифицирующая переменную никогда не будет выполнена, интерпретатор это проверить не может, и переменная все равно считается локальной. Пример:

def f(): print(a) if False: a = 0 a = 1 f()

Возникает ошибка: UnboundLocalError: local variable ‘a’ referenced before assignment . А именно, в функции f() идентификатор a становится локальной переменной, т.к. в функции есть команда, модифицирующая переменную a , пусть даже никогда и не выполняющийся (но интерпретатор не может это отследить). Поэтому вывод переменной a приводит к обращению к неинициализированной локальной переменной.

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

def f(): global a a = 1 print(a) a = 0 f() print(a)

В этом примере на экран будет выведено 1 1, так как переменная a объявлена, как глобальная, и ее изменение внутри функции приводит к тому, что и вне функции переменная будет доступна.

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

Например, пусть ваша программа должна посчитать факториал вводимого числа, который вы потом захотите сохранить в переменной f. Вот как это не стоит делать:

def factorial(n): global f res = 1 for i in range(2, n + 1): res *= i f = res n = int(input()) factorial(n) # дальше всякие действия с переменной f

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

Гораздо лучше переписать этот пример так:

# начало куска кода, который можно копировать из программы в программу def factorial(n): res = 1 for i in range(2, n + 1): res *= i return res # конец куска кода n = int(input()) f = factorial(n) # дальше всякие действия с переменной f

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

return [a, b]

Тогда результат вызова функции можно будет использовать во множественном присваивании:

Интересности и полезности python. Часть 3

В предыдущих частях мы рассмотрели срезы, распаковку\упаковку коллекций и некоторые особенности булевых операций и типов.

В комментариях упоминалась возможность умножения коллекций на скаляр:

a = [0] * 3 s = 'a' * 2 print(a, s) # -> [0, 0, 0], 'aa' 

Более-менее опытный разработчик на языке python знает, что в нём отсутствует механизм копирования при записи

a = [0] b = a b[0] = 1 print(a, b) # -> [1], [1] 

Что же тогда выведет следующий код?

b = a * 2 b[0] = 2 print(a, b) 

Python в данном случае работает по принципу наименьшего удивления: в переменной a у нас хранится одна единица, то есть b можно было объявить и как

b = [1] * 2 

Поведение в данном случае будет такое же:

b = a * 2 b[0] = 2 print(a, b) # -> [1], [2, 1] 

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

row = [0] * 2 matrix = [row] * 2 print(matrix) # -> [[0, 0], [0, 0]] matrix[0][0] = 1 print(matrix) # -> [[1, 0], [1, 0]] 

Генераторы списков и numpy вам в помощь в данном случае.

Списки можно складывать и даже инкрементировать, при этом справа может находиться любой итератор:

a = [0] a += (1,) a += a += "ab" a += print(a) # -> [0, 1, 2, 'a', 'b', 1] Заметьте, что строка вставилась посимвольно # ведь именно так работает строковый итератор 

Вопрос с подвохом (для собеседования): в python параметры передаются по ссылке или по значению?

def inc(a): a += 1 return a a = 5 print(inc(a)) print(a) # -> 5 

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

def appended(a): a += [1] return a a = [5] print(appended(a)) # -> [5, 1] print(a) # -> [5, 1] 

В таких языках как C++ есть переменные, хранящиеся на стеке и в динамической памяти. При вызове ф-ции мы помещаем все аргументы на стек, после чего передаём управление функции. Она знает размеры и смещения переменных на стеке, соответственно может их правильно интерпретировать.
При этом у нас есть два варианта: скопировать на стек память переменной или положить ссылку на объект в динамической памяти (или на более высоких уровнях стека).
Очевидно, что при изменении значений на стеке функции, значения в динамической памяти не поменяются, а при изменении области памяти по ссылке, мы модифицируем общую память, соответственно все ссылки на эту же область памяти «увидят» новое значение.

В python отказались от подобного механизма, заменой служит механизм связывания(assignment) имени переменной с объектом, например при создании переменной:

var = "john" 

Интерпретатор создаёт объект «john» и «имя» var, а затем связывает объект с данным именем.
При вызове функции, новых объектов не создаётся, вместо этого в её области видимости создаётся имя, которое связывается с существующим объектом.
Но в python есть изменяемые и неизменяемые типы. Ко вторым, например, относятся числа: при арифметических операциях существующие объекты не меняются, а создаётся новый объект, с которым потом связывается существующее имя. Если же со старым объектом после этого не связано ни одного имени, оно будет удалено с помощью механизма подсчёта ссылок.
Если же имя связано с переменной изменяемого типа, то при операциях с ней изменяется память объекта, соответственно все имена, связанные с данной областью памяти «увидят» изменения.

Можно почитать про это в документации, более подробно изложено здесь.

Ещё один пример:

a = [1, 2, 3, 4, 5] def rev(l): l.reverse() return l l = a print(a, l) # -> [1, 2, 3, 4, 5], [1, 2, 3, 4, 5] l = rev(l) print(a, l) # -> [5, 4, 3, 2, 1], [5, 4, 3, 2, 1] 

Но что, если мы решили поменять переменную вне функции? В данном случае нам поможет модификатор global:

def change(): global a a += 1 a = 5 change() print(a) 

Замечание: не надо так делать (нет, серьёзно, не используйте глобальные переменные в своих программах, и тем более не в своих). Лучше просто вернуть несколько значений из функции:

def func(a, b): return a + 1, b + 1 

Однако, в python присутствует и другая область видимости и соответствующее ключевое слово:

def private(value=None): def getter(): return value def setter(v): nonlocal value value = v return getter, setter vget, vset = private(42) print(vget()) # -> 42 vset(0) print(vget()) # -> 0 

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

def private(value=None): def getter(): return value def setter(v): nonlocal value value = v return getter, setter class Person: def __init__(self, name): self.getid, self.setid = private(name) adam = Person("adam") print(adam.getid()) print(adam.setid("john")) print(adam.getid()) print(dir(adam)) 

Но, пожалуй, лучше будет ограничиться свойствами или определением __getattr__, __setattr__.

Можете даже определить __delattr__.

Ещё одной особенностью python является наличие двух методов для получения атрибута: __getattr__ и __getattribute__.

В чём между ними разница? Первый вызывается лишь, если атрибут в классе не был найден, а второй безусловно. Если в классе объявлены оба, то __getattr__ вызовется, лишь, если явно его вызвать в __getattribute__ или, если __getattribute__ сгенерировал AttributeError.

class Person(): def __getattr__(self, item): print("__getattr__") if item == "name": return "john" raise AttributeError def __getattribute__(self, item): print("__getattribute__") raise AttributeError person = Person() print(person.name) # -> __getattribute__ # -> __getattr__ # -> john 

И на последок пример того, как python вольно обращается с переменными и областями видимости:

 e = 42 try: 1 / 0 except Exception as e: pass print(e) # -> NameError: name 'e' is not defined 

Это, кстати, пожалуй единственный пример, когда второй python лучше третьего, потому что он выводит:

 . print(e) # -> float division by zero 

Что выведет следующий код var 10 print var

Скачай курс
в приложении

Перейти в приложение
Открыть мобильную версию сайта

© 2013 — 2023. Stepik

Наши условия использования и конфиденциальности

Public user contributions licensed under cc-wiki license with attribution required

Python 3 — Функции

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

Как вы уже знаете, Python предоставляет множество встроенных функций, таких как print() и т.д., но вы также можете создавать свои собственные функции. Эти функции называются определяемые пользователем функции.

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

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

• Функциональные блоки начинаются с ключевым словом def следует имя функции и скобки (()).
• Любые входные параметры или аргументы должны быть размещены в этих скобках. Вы также можете определить параметры внутри этих скобок.
• Первый оператор функции может быть необязательным заявление — строкой документации функции или строкой документации.
• Блочный код в пределах каждой функции начинается двоеточием (:) и с отступом.
• Утверждение return [выражение] делает выход из функции, необязательно передавая обратно выражение для вызывающего. Ответное заявление без аргументов такого же, как возвратное none.

Синтаксис

def functionname( parameters ): "function_docstring" function_suite return [expression]

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

Пример

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

def printme( str ): "Это печатает переданную строку в эту функцию" print (str) return

Вызов функции

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

После того, как основная структура функции завершена, вы можете выполнить его, вызвав его из другой функции или непосредственно из командной строки Python. Ниже приведен пример для вызова функции PrintMe():

#!/usr/bin/python3 # FЗдесь вызов функции def printme( str ): "Это печатает переданную строку в эту функцию" print (str) return # Теперь вы можете вызвать функцию printme printme("Это первый вызов определяемой пользователем функции!") printme("Опять второй вызов той же функции")

Когда этот код выполниться, он выведет следующий результат:

Это первый вызов определяемой пользователем функции! Опять второй вызов той же функции

Передавать по ссылке против значения

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

#!/usr/bin/python3 # Здесь определение функции def changeme( mylist ): "Это изменяет переданный список в эту функцию" print ("Значения внутри функции перед изменением: ", mylist) mylist[2]=31 print ("Значение внутри функции после изменения: ", mylist) return # Теперь можно вызвать функцию changeme mylist = [10,20,30] changeme( mylist ) print ("Значения вне функции: ", mylist)

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

Значения внутри функции перед изменением: [10, 20, 30] Значение внутри функции после изменения: [10, 20, 31] Значения вне функции: [10, 20, 31]

Существует еще один пример, в котором аргумент передается по ссылке, а ссылка перезаписи внутри вызываемой функции.

#!/usr/bin/python3 # Здесь определение функции def changeme( mylist ): "Это изменяет список в этой функции" mylist = [1,2,3,4] # This would new reference in mylist print ("Значения внутри функции: ", mylist) return # Теперь можно вызвать функцию changeme mylist = [10,20,30] changeme( mylist ) print ("Значения вне функции: ", mylist)

Параметр MyList является локальным по отношению к функции ChangeMe. Изменение MyList внутри функции не влияет на MyList. Функция ничего не выполняет, и, наконец, это произведет следующий результат:

Значения внутри функции: [1, 2, 3, 4] Значения вне функции: [10, 20, 30]

Аргументы функции

Вы можете вызвать функцию с помощью следующих типов формальных аргументов:

• Необходимые аргументы
• Ключевые аргументы
• Аргументы по умолчанию
• Аргументы переменной длины

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

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

Для вызова функции PrintMe(), вам обязательно нужно передать один аргумент, в противном случае она выдаст синтаксическую ошибку следующим образом:

#!/usr/bin/python3 # Здесь определение функции def printme( str ): "Это печатает переданную строку в эту функцию" print (str) return # Теперь вы можете вызвать функцию printme printme()

Когда этот код выполниться, он выведет следующий результат:

Traceback (most recent call last): File "test.py", line 11, in printme(); TypeError: printme() takes exactly 1 argument (0 given)

Ключевое слово аргумент

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

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

#!/usr/bin/python3 # Здесь определение функции def printme( str ): "Это печатает переданную строку в эту функцию" print (str) return # Теперь вы можете вызвать функцию printme printme( str = "Моя строка")

Когда этот код выполниться, он выведет следующий результат:

Моя строка

Следующий пример дает более четкую картину. Обратите внимание, что порядок параметров не имеет значения.

#!/usr/bin/python3 # Здесь определение функции def printinfo( name, age ): "Это печатает переданную информацию в эту функцию" print ("Имя: ", name) print ("Возраст ", age) return # Теперь можно вызвать функцию printinfo printinfo( age = 31, name = "AndreyEx" )

Когда этот код выполниться, он выведет следующий результат:

Имя: AndreyEx Возраст 31

Аргументы по умолчанию

Аргументы по умолчанию является аргументами, которые принимают значение по умолчанию, если значение не предусмотрено в вызове функции для этого аргумента. Следующий пример дает представление о аргументах по умолчанию, он печатает по умолчанию возраст, если он не прошел:

#!/usr/bin/python3 # Здесь определение функции def printinfo( name, age = 35 ): "Это печатает переданную информацию в эту функцию" print ("Name: ", name) print ("Age ", age) return # Теперь можно вызвать функцию printinfo printinfo( age = 31, name = "AndreyEx" ) printinfo( name = "AndreyEx" )

Когда этот код выполниться, он выведет следующий результат:

Имя: AndreyEx Возраст 31 Имя: AndreyEx Возраст 35

Аргументы переменной длины

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

Синтаксис для функции с не-ключевыми словами переменными аргументами приводятся ниже:

def functionname([formal_args,] *var_args_tuple ): "function_docstring" function_suite return [expression]

Звездочкой (*) ставится перед именем переменной, которая содержит значения всех nonkeyword переменных аргументов. Этот кортеж остается пустым, если никакие дополнительные аргументы не указаны при вызове функции. Ниже приведен простой пример:

#!/usr/bin/python3 # Здесь определение функции def printinfo( arg1, *vartuple ): "Эта печать переменные аргументы" print ("Вывод: ") print (arg1) for var in vartuple: print (var) return # Теперь можно вызвать функцию printinfo printinfo( 10 ) printinfo( 70, 60, 31 )

Когда этот код выполниться, он выведет следующий результат:

Вывод: 10 Вывод: 70 60 31

Анонимная функция

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

• Форма Lambda может принимать любое количество аргументов, но возвращать только одно значение в виде выражения. Они не могут содержать команды или несколько выражений.
• Анонимная функция не может быть прямым вызовом для печати, потому что Lambda требует выражений.
• Лямбда-функция имеет свои собственные локальное пространство имен и не может получить доступ к другим, чем в их списке параметров, и те, в глобальном пространстве имен переменных.
• Хотя кажется, что Lambda являются разновидностью одной строки функции, они не эквивалентны встроенными операторов в C или C ++, чья цель состоит в том, чтобы стек распределялся путем передачи функции во время вызова по соображениям производительности.

Синтаксис

Синтаксис Lambda — функций содержит только один оператор, который выглядит следующим образом:

lambda [arg1 [,arg2. argn]]:expression

Ниже приведен пример, чтобы показать, как работает форма функции Lambda:

#!/usr/bin/python3 # Здесь определение функции sum = lambda arg1, arg2: arg1 + arg2 # Теперь вы можете вызвать sum как функцию print ("Общая стоимость : ", sum( 10, 20 )) print ("Общая стоимость : ", sum( 20, 20 ))

Когда этот код выполниться, он выведет следующий результат:

Общая стоимость : 30 VОбщая стоимость : 40

Заявление return

Заявление return [выражение] выводит из функции, необязательно передавая обратно выражение для вызывающего. Ответное заявление без аргументов такое же, как возвратный none.

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

#!/usr/bin/python3 # Здесь определение функции def sum( arg1, arg2 ): # Добавьте оба параметра и верните их." total = arg1 + arg2 print ("Внутри функции : ", total) return total # Теперь можно вызвать функцию sum total = sum( 10, 20 ) print ("Вне функции : ", total )

Когда этот код выполниться, он выведет следующий результат:

Внутри функции : 30 Вне функции : 30

Область действия переменных

Все переменные в программе не могут быть доступны во всех местах, в этой программе. Это зависит от того, где вы объявили переменную.

Область видимости переменной определяет часть программы, где вы можете получить доступ к конкретному идентификатору. Есть две основные области видимости переменных в Python:

• Глобальные переменные
• Локальные переменные

Глобальные переменные против локальных переменных

Переменные, определенные внутри тела функции имеют локальную область видимости, а также те, которые определены вне имеют глобальный масштаб.

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

#!/usr/bin/python3 total = 0 # Это глобальная переменная. # Здесь определение функции def sum( arg1, arg2 ): # Add both the parameters and return them." total = arg1 + arg2; # Здесь локальная переменная как глобальная. print ("Итого локально внутри функции : ", total) return total # Теперь можно вызвать функцию sum sum( 10, 20 ) print ("Итого глобально вне функции : ", total )

Когда этот код выполниться, он выведет следующий результат:

Итого локально внутри функции : 30 Итого глобально вне функции : 0