Введение в Python #5: функции часть вторая
Vladislav Z - создатель канала x[code] & fullstack dev Python |Привет-привет! В этом уроке мы продолжим изучение функций. Посмотрим как создаются комментарии, подсказывающие разработчикам. Научимся использовать стандартные функции языка Python. Так же узнаем о глобальных и локальных переменных.
В Python есть очень полезная строка, которую можно применять как к переменным так и в целях описания функции. Эту строку мы обозначаем в начале """ и в конце """. Это особый вид строки. Который если будет записан в переменную выдаст нам тот текст который мы записали, учитывая пробелы и все символы. Пример:
test_text = """ Этот текст будет отображаться именно
в
OТ т
а
к
"""
Теперь попробуйте вывести эту переменную на экран. Понятно? Понятно. Идем дальше А теперь применим это всё дело на документации, если вы используете PyCharm или Microsoft Visual Studio 2019 то при наведении даже на такие банальные функции как print(), мы получаем описывающий текст, а если используем на нашу функцию команду help(print), мы снова же увидим этот наш полезный текст, который кстати в будущем вы научитесь читать! Так вот чтобы такой текст создать, нам всего лишь нужно сделать вот так:
def some_func(var1,va2):
""" Эта функция была создана для тестовых проб, не пытайтесь повторить это в домашних условиях! Шутка :) Шутка :) Кстати здесь же и описывается что делает эта функция, какие параметры она использует, что будет возвращать и тд. Весьма полезная штука в полевых условиях, так как после написания 200 строк, уже начинаешь путаться и забывать какие локальные переменные были созданы! """
print(var1)
print(var2)
return 'Nothing'
Теперь чтобы увидеть этот текст нам просто нужно обратился к функции help:
help(some_func)
Надеюсь тут всё понятно.
Далее давай рассмотрим встроенные функции, с некоторыми вы уже знакомы.
- abs(x) – модуль числа x
- bin(x) – представление числа x в двоичной системе счисления
- bool(x) – создать значение типа bool из x
- callable(f) – проверить, можно ли f вызывать как функцию
- chr(code) – символ с кодом code
- complex(real, imag) – создать комплексное число
- dir(obj) – вывести список полей и методов объекта obj
- float(x) – создать вещественное число из x
- format(x, fmt) – возвращает строку, представляющую значение x, отформатированное согласно форматной строке fmt
- help(obj) – выводит справку по объекту obj
- hex(x) – шестнадцатеричное представление числа x
- id(obj) – значение, уникальное для каждого объекта (в CPython – адрес объекта в памяти)
- input() – ввод данных
- int(x) – создать целое число
- len(s) – длина строки или любой другой последовательности
- max(arg1, arg2, ...) – максимальное число среди заданных
- min(arg1, arg2, ...) – минимальное число среди заданных
- oct(x) – представление числа x в восьмеричной системе счисления
- ord(c) – код символа c
- pow(x, n) – число x в степени n
- print() – вывод данных
- range() – последовательность целых чисел (см. урок про циклы)
- repr(obj) – строковое представление объекта
- reversed(iterable) – обход последовательности в обратном порядке
- round(number, ndigits) – округление числа
- sorted(iterable) – сортирует последовательность в порядке возрастания или убывания значений
- str(x) – создание строки из x
Попробуйте поиграться с каждой функцией, это и правда интересно.
Так же любой язык программирования поддерживает вложенные функции. Очень полезно когда нужно выполнить какую-то реализацию непосредственно в самой функции. И закрыть эту функцию от внешнего воздействия, так как мы имеем такое представление как глобальные и локальные переменные, об этом немного позже. Вложенные функции имеют доступ к внешним переменным и аргументам, но недоступны за пределами тех функций в которой были определенны.
И так чтобы создать вложенную функцию, достаточно ее просто вписать внутри нашей внешней. Например:
def outer_function():
def inner_function():
print('Внутренняя функция')
print('Внешняя функция')
inner_function()
Теперь чтобы вызвать все это, нам нужно обратится к внешней функции, то есть к outer_function(). Но как было сказано выше, если мы вызовем inner_function(), получим ошибку. А все потому что у нас есть такое понятие как область видимости переменных.
Область видимости - это обозначение области программы в пределах которой идентификатор некоторой переменной будет связан с этой переменной и возвращать ее значение. А за пределами области видимости в другой области тот же самый идентификатор может (его имя) может иметь совсем другое значение или не иметь вообще никаких значений.
Сложно? Давайте еще раз только с другой стороны. Смоделируем ситуацию: у нас есть сайт в которой есть переменная name, мы ее получили от нашего пользователя который только что зашел на сайт, то есть его имя на данный момент локально относительно его клиента(компьютера), но есть же и другие имена правильно? Они все не относятся к нашему пользователю, глобально у нас есть кучу имен. Но у нас есть функция которая будет допустим в личном кабинете выводить информацию о пользователе. И эта наша глобальная переменная name находит именно нашего пользователя и делает ее локальной, потому что у нас функция которая вытягивает эту переменную и делает ее локальной. Ну а что если мы из локальной области видимости попробуем обратится к глобальным переменным? Ничего не будет. Потому что наша область видимости не позволяет нам получить данные.
Еще не понятно? Идем дальше. Сейчас разрулим этот сложный вопрос.
В языках поддерживающих структурное программирование переменные обычно разделяются на два типа:
- глобальные переменные
- локальные переменные
- Глобальные переменные объявляются вне всех функций и доступны отовсюду.
- Глобальная переменная может быть изменена в любой точке программы, что может повлиять на выполнение программы.
name = 'x code' #это глобальная переменная
def func_punk():
print(name)
- Локальные переменные объявляются внутри функций и недоступны снаружи её.
- Переменные локальной области используются для того, чтобы избежать проблем с побочными эффектами, которые могут произойти с глобальными переменными.
- В Python локальной областью видимо является функция. В некоторых языках любой блок может иметь свои локальные переменные.
- Операция присвоения в функции создает локальную переменную, если необходимо изменить значение переменной из другой области видимости, следует воспользоваться операторами global или nonlocal
def func_punk():
name = 'x code' #это локальная переменная
Как еще пример, у нас есть две одинаковые переменные, одна глобальная другая локальная, попробуем изменить значение глобальной переменной в локальной среде и в глобальной видимости вывести значение на экран.
name = 'x code'
def func():
name = 'Local x code'
func()
print(name)
Что мы получим? Попробуйте сами.
И все же а если мы хотим изменить значение глобальной переменной, как нам это сделать? А очень просто, объявить внутри функции, переменную name глобальной:
name = 'x code'
def func():
global name
name = 'Inner x code '
func()
print(name)
Вуаля, мы получили желаемый результат.
Кстати переменные, указанные в операторе nonlocal, рассматриваются как переменные из ближайшей области видимости (внешняя функция в случае вложенных функций или глобальная область видимости, если сама функция является глобальной).
Память под локальные переменные выделяется при каждом вызове функции. Поэтому если у вас объявлена одна функция, и вы вызовете ее 10 раз, то под каждая вызванная функция будет рассмотрена в памяти как отдельный объект, логично, потому как каждый раз функция может вызываться с разными значениями. А так же это дает нам возможность работать с рекурсиями.
Ох уж эти рекурсии..для начала советую вам посмотреть один видео-ролик: что такое рекурсии <<< нажми :)
И так теперь когда вы посмотрели ролик, давайте рассмотрим это еще раз.
Рекурсии - это вызов функции из неё же самой, непосредственно ( простая рекурсия) или через другие функции(сложная или косвенная рекурсия), например функция А вызывает функция Б, а функция Б вызывает функцию А.
Количество вложенных рекурсий называется глубинной рекурсии.
Пример рекурсивной функции.
def factorial(n):
if n == 0:
return 1 # условие выхода
else:
return n * factorial(n - 1) # рекурсивный вызов
# вычисление факториала числа 5
print(factorial(5))
- Что такое документационная строка?
- Можно ли в Python объявлять функции внутри других функций?
- Назовите несколько стандартных функций языка Python.
- Что такое область видимости?
- Что такое локальная переменная?
- Что такое глобальная переменная?
- Напишите рекурсивную функцию, которая вычисляет сумму натуральных чисел, которые входят в заданный промежуток.
- Прочитайте в документации по языку Python информацию о перечисленных в резюме данного урока стандартных функциях. Проверьте их на практике.
- Создайте программу, которая проверяет, является ли палиндромом введённая фраза.
- Пусть на каждую ступеньку лестницы можно стать с предыдущей или переступив через одну. Определите, сколькими способами можно подняться на заданную ступеньку.