Самоучитель
Содержание:
Рекурсивная функция Python
Когда функция вызывает сама себя, она называется рекурсивной функцией. В программировании этот сценарий называется рекурсией.
Вы должны быть очень осторожны при использовании рекурсии, потому что есть вероятность, что функция никогда не завершится и перейдет в бесконечный цикл. Вот простой пример печати ряда Фибоначчи с использованием рекурсии.
def fibonacci_numbers_at_index(count):
if count <= 1:
return count
else:
return fibonacci_numbers_at_index(count - 1) + fibonacci_numbers_at_index(count - 2)
count = 5
i = 1
while i <= count:
print(fibonacci_numbers_at_index(i))
i += 1
Полезно знать о рекурсии, но в большинстве случаев при программировании это не нужно. То же самое можно сделать с помощью цикла for или while.
Использование лямбда-выражений вместо функций
Для простых функций, например , который просто вычисляют квадрат числа, можно использовать лямбда-выражения.
>>> square = lambda x x 2
>>> print(square(5))25
В начале создается переменная square и в дальнейшем по имени переменной будет вызываться лямбда-выражение. Лямбда-выражение является анонимной функцией, то есть функцией, не имеющей имени. Лямбда-выражение начинается с ключевого слова lambda, за которым следует разделенный запятыми список параметров. В нашем примере параметр один x. Затем ставится двоеточие и само выражение x ** 2. В результате при вызове переменной square мы передаем параметр число 5, и оно возводится в квадрат.
Лямбда-выражение может иметь и несколько параметров. Например, перемножать передаваемые числа.
>>> mult = lambda x, y, z x * y * z
>>> print(mult(2, 4, 6))48
Таким образом любая простая функция в форме
def имя_функции(список_параметров):
return выражение
может быть выражена в более компактной форме посредством лямбда-выражения
lambda список_параметров выражение
1. Установка Python 2. Выбор текстового редактора 3. Запуск программ Python в командной строке 4. Числа и арифметические операторы Python 5.Строки и функция Print в Python 6. Списки и кортежи в Python 7. Сегментация последовательностей в Python 8. Цикл for и функция range в Python 9. Команда if и функция input в Python 10. Словари в Python 11. Множества в Python 12. Цикл while в Python 13. Функции в Python 14. Классы в Python 15. Файлы и исключения в Python 16. Функции json. Сохранение данных Python 17.Тестирование функций и классов на Python
Please enable JavaScript to view the comments powered by Disqus.
Функции Python 3 — возврат значения
Можно передавать значение аргумента функции в Python. При этом функция также может возвращать значение с помощью инструкции return, которая завершит выполнение функции и передаст значения к месту ее вызова. Используя return без аргументов, функция будет возвращать None.
До сих пор мы использовали print(), а не return. Создадим программу, которая вместо вывода в терминал будет возвращать переменную.
В новом текстовом файле создадим программу, которая будет возводить в квадрат параметр x и возвращать переменную y. Выполняем вызов, чтобы вывести переменную result после запуска функции square() с аргументом 3:
square.py
def square(x):
y = x ** 2
return y
result = square(3)
print(result)
Запускаем программу, чтобы увидеть результат:
python square.py Результат 9
В качестве выходных данных получаем число 9, что и является результатом возведения в квадрат числа 3. Рассмотрим действие инструкции return в программе:
square.py
def square(x):
y = x ** 2
# return y
result = square(3)
print(result)
Снова запускаем программу:
python square.py Результат None
Без return программа не может вернуть значение, поэтому оно равно None.
В следующем примере математической функции в Python заменим print() из программы add_numbers.py на инструкцию return:
add_numbers.py
def add_numbers(x, y, z):
a = x + y
b = x + z
c = y + z
return a, b, c
sums = add_numbers(1, 2, 3)
print(sums)
Вне функции объявляем переменную sums, которая равна результату действия функции для чисел 1, 2 и 3 из примера, приведенного выше. Затем выводим переменную sums. Снова запускаем программу, теперь уже с инструкцией return:
python add_numbers.py Результат (3, 4, 5)
На выходе получаем те же числа, что и с использованием инструкции print(). Теперь результат предоставлен в виде кортежа, так как в списке выражений инструкции return имеется запятая.
Функции Python немедленно завершаются, когда встречают инструкцию return, независимо от того, возвращают они значение или нет:
return_loop.py
def loop_five():
for x in range(0, 25):
print(x)
if x == 5:
# Функция останавливается на x == 5
return
print("Эта строка не будет выполняться.")
loop_five()
Инструкция return в цикле for завершает функцию, поэтому строка вне цикла не будет выполняться. При использовании инструкции break был бы завершен только цикл, и выполнялась последняя строка print().
Инструкция return завершает функцию и может возвращать значение в случае применения параметров.
Использования функции в цикле while
Функции могут вызываться в циклах while где угодно. Приведем пример цикла while, где у посетителя запрашивают имя и фамилию, а с помощью функции form_name возвращается отформатированное имя и фамилия с приветствием:
def form_name(first_name, last_name):
«»»Возвращает отформатированное полное имя»»»
full_name = «{first_name} {last_name}»
return full_name.
while True:
print(«Введите ‘x’ если хотите завершить программу»)
first_name = («Введите ваше имя: «)
first_name == ‘x’:
break
last_name = («Введите вашу фамилию: «)
last_name == ‘x’:
break
formatted_name = form_name(first_name, last_name)
print(«Добрый день {formatted_name}!»)
В данном примере в цикле whle запрашивается имя и фамилия и с помощью функции form_name возвращается отформатированное полное имя и записывается в переменную formatted_name. А затем уже с помощью функции данные выводятся на экран.
Default arguments
A default argument is an argument that assumes a default value if a value is not provided in the function call for that argument. The following example gives an idea on default arguments, it prints default age if it is not passed −
#!/usr/bin/python # Function definition is here def printinfo( name, age = 35 ): "This prints a passed info into this function" print "Name: ", name print "Age ", age return; # Now you can call printinfo function printinfo( age=50, name="miki" ) printinfo( name="miki" )
When the above code is executed, it produces the following result −
Name: miki Age 50 Name: miki Age 35
self
Рассотрим пример. Пусть у нас есть объект мяч — ball , обладающий атрибутами и методами.
Атрибуты мяча могут быть:
ball.color - цвет, например, красныйball.size - размер, например, маленькийball.price – стоимость мяча
Методы нашего объекта могут выглядеть следующим образом:
ball.Move( ) - перемещение мячаball.Show( ) – вывести характеристики (атрибуты) мяча на экран
Переменная self указывает на конкретный объект экземпляра класса. Доступ к атрибутам и методам осуществляется через переменную self. Это главное назначение переменной self.
Предположим мы создали три мяча — экземпляры класса Ball: ball1, ball2, ball3.Мячи могут иметь разные характеристики, например, как в таблице.
|
Объект |
Self |
Color |
Size |
Price |
|
|
имя объекта |
адрес объекта |
||||
|
ball1 |
адрес 1 |
адрес 1 |
Красный |
Маленький |
10 |
|
ball2 |
адрес 2 |
адрес 2 |
Синий |
Средний |
20 |
|
ball3 |
адрес 3 |
адрес 3 |
Белый |
Большой |
30 |
Переменная self представляет ссылку на экземпляр класса, т.е. содержит адрес объекта. Всем методам класса автоматически передается эта ссылка.
Предположим в классе Ball имеется метод Show( ) – вывести характеристики мяча.
Что такое питон простыми словами
Для того чтобы понять, что такое Python нужно разобраться зачем вообще нужны языки программирования. Они нужны для взаимодействия человека и компьютера. Между собой люди общаются на естественном языке.
Язык программирования Python
Питон является относительно простым высокоуровневым скриптовым языком, который служит для создания различных сценариев. Это означает, что для программирования на Python, не требуется знания машинных кодов — команд для компьютера.
Программирование при помощи машинных кодов ускоряет программу, но очень трудоемко и требует хорошего знания архитектуры компьютера. Одним из таких низкоуровневых языков является ассемблер. Чаще всего низкоуровневое программирование используется в промышленности для специализированных контроллеров, где нет большого объема памяти.
Python может использоваться для программирования контроллеров в станках ЧПУ и в робототехнике. Популярный во всем мире одноплатный микрокомпьютер Raspberry Pi также программируется на питоне. С помощью «малинки» можно программировать роботов, умные дома, квадрокоптеры и множество других вещей. Pi в названии миникомпьютера обозначает, что программирование происходит на Python.
одноплатный микрокомпьютер Raspberry Pi
На языке высокого уровня нужно уметь программировать при помощи понятий, обозначаемых словами. Чаще всего это английский язык, но есть и примеры кодирования на других языках. Например, программу «Бухгалтерия 1С» можно редактировать и изменять на русском.
Питон поддерживает объектно-ориентированное программирование и является интерпретируемым языком. Это означает, что программа выполняется построчно и для ее выполнения на компьютере должен быть установлен интерпретатор. Самым распространенным и популярным интерпретатором является CPython.
Функции ввода ()
Многое временем в программе нам нужен какой-то вход от пользователя. Принимая входы от пользователя заставляет программу чувствовать себя интерактивными. В Python 3, чтобы принять вклад от пользователя, у нас есть функция Отказ Если вызывается функция ввода, поток программы будет остановлен до тех пор, пока пользователь не дал ввод и закончил вход с ключом возврата. Давайте посмотрим некоторые примеры:
Когда мы просто хотим взять вклад:
INP ()
Запустите код
Дать подсказку с сообщением:
Подскажите с сообщение(”)
Запустите код
3. Когда мы хотим взять целочисленный вход:
number = int(input('Please enter a number: '))
Запустите код
Если вы вводите не целочисленное значение, то Python бросит ошибку Отказ Поэтому, когда вы используете это, пожалуйста, убедитесь, что вы тоже поймаете. В противном случае ваша программа неожиданно прекратится после подсказки.
number = int(input('Please enter a number: '))
# Please enter a number: as
# Enter a string and it will throw this error
# ValueError: invalid literal for int() with base 10 'as'
4. Когда мы хотим ввод строки:
string = str(input('Please enter a string: '))
Запустите код
Хотя входы хранятся по умолчанию как строка. Используя Функция делает его понятно для читателя кода, что вход будет «строка». Хорошей практикой, чтобы упомянуть, какой тип ввода будет предпринят заранее.
Официальные документы
Область видимость и глобальные переменные
Концепт области (scope) в Пайтон такой же, как и в большей части языков программирования. Область видимости указывает нам, когда и где переменная может быть использована. Если мы определяем переменные внутри функции, эти переменные могут быть использованы только внутри это функции. Когда функция заканчиваются, их можно больше не использовать, так как они находятся вне области видимости. Давайте взглянем на пример:
Python
def function_a():
a = 1
b = 2
return a+b
def function_b():
c = 3
return a+c
print( function_a() )
print( function_b() )
|
1 2 3 4 5 6 7 8 9 10 11 12 |
deffunction_a() a=1 b=2 returna+b deffunction_b() c=3 returna+c print(function_a()) print(function_b()) |
Если вы запустите этот код, вы получите ошибку:
Python
NameError: global name ‘a’ is not defined
| 1 | NameErrorglobalname’a’isnotdefined |
Это вызвано тем, что переменная определенна только внутри первой функции, но не во второй. Вы можете обойти этот момент, указав в Пайтоне, что переменная а – глобальная (global). Давайте взглянем на то, как это работает:
Python
def function_a():
global a
a = 1
b = 2
return a+b
def function_b():
c = 3
return a+c
print( function_a() )
print( function_b() )
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
deffunction_a() globala a=1 b=2 returna+b deffunction_b() c=3 returna+c print(function_a()) print(function_b()) |
Этот код работает, так как мы указали Пайтону сделать а – глобальной переменной, а это значит, что она работает где-либо в программе. Из этого вытекает, что это настолько же хорошая идея, насколько и плохая. Причина, по которой эта идея – плохая в том, что нам становится трудно сказать, когда и где переменная была определена. Другая проблема заключается в следующем: когда мы определяем «а» как глобальную в одном месте, мы можем случайно переопределить её значение в другом, что может вызвать логическую ошибку, которую не просто исправить.
Термины и определения
Ключевое слово в начале функции сообщает интерпретатору о том, что следующий за ним код – есть её определение. Всё вместе – это объявление функции.
Аргументы часто путают с параметрами:
- Параметр – это переменная, которой будет присваиваться входящее в функцию значение.
- Аргумент – само это значение, которое передается в функцию при её вызове.
Параметры и аргументы функции
Ключевая особенность функций – возможность возвращать значение.
Для этого используется слово . Предположим, вы часто умножаете числа. Вы не осведомлены заранее, целые они или вещественные, но хотите, чтобы результат был целым всегда. Решим задачу с помощью функции:
️ Главная фишка возвращаемых значений в том, что их можно использовать в дальнейшем коде: присваивать переменным, совершать с ними разные операции и передавать как аргументы в другие функции.
Функции Python 3 — значения аргументов по умолчанию
Также можно указать значения по умолчанию для обоих параметров. Создадим значение по умолчанию для параметра followers со значением 1:
profile.py
def profile_info(username, followers=1):
print("Имя Username: " + username)
print("Followers: " + str(followers))
Теперь можно запустить функцию с параметром username, а число подписчиков по умолчанию будет 1. При желании можно изменить количество пользователей:
profile.py
def profile_info(username, followers=1):
print("Имя Username: " + username)
print("Followers: " + str(followers))
profile_info(username="JOctopus")
profile_info(username="sammyshark", followers=945)
Запустив программу командой python profile.py, получаем следующее:
Результат Username: JOctopus Followers: 1 Username: sammyshark Followers: 945
Определяя начальные параметры, не нужно устанавливать значения для каждого аргумента.
Функция All()
Функция возвращает True, если все элементы в итерируемом типе являются истинными. Рассмотрим следующий пример:
item_list = print (all(item_list))
При вызове функции в качестве аргумента в неё передаётся итерируемый объект . После выполнения кода выше вы получите следующий результат:
True
В данном случае функция вернула значение True, так как все элементы в итерируемом объекте равны True.
Любые непустые строки всегда рассматриваются как True.
item_list = print (all(item_list))
Код вернёт следующий результат:
Если список совершенно пуст, всегда будет возвращать True.
item_list = [] print (all(item_list))
Получаем:
Если некоторые элементы итерируемого объекта – пустые строки, при вызове они считаются False:
item_list = print (all(item_list))
При запуске данного фрагмента кода вы получите следующий результат:
Так как последний элемент (пустая строка) в был False, функция вернула значение False.
Если элемент равен 0 (тип , пишется без кавычек), функция расценит его как False:
item_list = print (all(item_list))
Результат:
И, наконец, если элемент просто равен False (булево значение), вернёт False:
item_list = print (all(item_list))
Результат:
То есть, если передать в функцию не пустой итерируемый объект, она всегда будет возвращать , если в объекте не окажется следующих трех значений:
- «» (пустая строка)
- 0 (без кавычек, тип )
- False (без кавычек, тип boolean)
Иногда вам может понадобиться преобразовать каждое значение итерируемого типа в True или False на основании определённых условий и затем вызвать для результата функцию . В этом случае вы можете использовать синтаксис списковых включений, чтобы напрямую передавать значения True или False в функцию:
item_list = print (all(item > 2 for item in item_list))
В функции синтаксис списковых включений используется там, где цикл пробегает по элементам . Каждый элемент в сравнивается с 2, и, если он больше, он становится True, в противном случае — False. Затем функция проверяет на истинность каждый элемент.
Вы можете проверить результат, добавив ещё один :
item_list = print (all(item > 2 for item in item_list)) print ()
Данный код выведет следующий результат:
Не все значения здесь истинны, поэтому функция вернёт False.
Именованные аргументы
Параметры можно вызывать не только ко порядку. Именованные аргументы позволяют вызывать параметры по имени.
При этом параметры можно вызывать в том порядке, в котором они определены. Интерпретатор Python будет использовать имя параметра для поиска требуемого значения.
Создайте функцию, которая будет выводить информацию о профиле пользователя. Откройте файл profile.py и передайте ей параметры username (строка) и followers (целое число).
В определении функции profile_info() параметры username и followers взяты в круглые скобки. Блок функции выводит строку с информацией о пользователе на основе двух параметров.
Вызовите функцию и присвойте ей параметры:
В первом вызове используется имя 8hostblog с количеством подписчиков 945. Во втором вызове используется именованные аргументы.
Запустите программу:
В выводе вы видите имя и количество подписчиков каждого пользователя.
Вы можете изменить порядок отображения параметров в этой программе:
Попробуйте снова запустить программу. Вы получите такой результат:
Благодаря именованным аргументам вы можете вызывать параметры функции в любом порядке.
Создание динамических классов
Допустим, у нас есть следующие классы.
class Data:
"""Data Class"""
d_id = 10
class SubData(Data):
"""SubData Class"""
sd_id = 20
Напечатаем некоторые свойства этих классов.
print(Data.__class__) print(Data.__bases__) print(Data.__dict__) print(Data.__doc__) print(SubData.__class__) print(SubData.__bases__) print(SubData.__dict__) print(SubData.__doc__)
Вывод:
<class 'type'>
(<class 'object'>,)
{'__module__': '__main__', '__doc__': 'Data Class', 'd_id': 10, '__dict__': <attribute '__dict__' of 'Data' objects>, '__weakref__': <attribute '__weakref__' of 'Data' objects>}
Data Class
<class 'type'>
(<class '__main__.Data'>,)
{'__module__': '__main__', '__doc__': 'SubData Class', 'sd_id': 20}
SubData Class
Мы можем создавать похожие классы с помощью функции type().
Data1 = type('Data1', (object,), {'__doc__': 'Data1 Class', 'd_id': 10})
SubData1 = type('SubData1', (Data1,), {'__doc__': 'SubData1 Class', 'sd_id': 20})
print(Data1.__class__)
print(Data1.__bases__)
print(Data1.__dict__)
print(Data1.__doc__)
print(SubData1.__class__)
print(SubData1.__bases__)
print(SubData1.__dict__)
print(SubData1.__doc__)
Вывод:
<class 'type'>
(<class 'object'>,)
{'__doc__': 'Data1 Class', 'd_id': 10, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'Data1' objects>, '__weakref__': <attribute '__weakref__' of 'Data1' objects>}
Data1 Class
<class 'type'>
(<class '__main__.Data1'>,)
{'__doc__': 'SubData1 Class', 'sd_id': 20, '__module__': '__main__'}
SubData1 Class
Обратите внимание, что мы не можем создавать функции в динамическом классе с помощью функции type()
Применение lambda в sort, filter, map, reduce
На практике сортировка – одна из самых популярных манипуляций с данными. Например, имеется список слов, которые нужно отсортировать по последней букве. Для этого нужно указать аргумент – функцию, с помощью которой будет происходить сравнение элементов. Этой функцией может служить наша lambda:
>>> words = >>> sorted(words, key=lambda x: x)
В качестве индекса мы указали -1, обозначающий последний элемент строки (str), т.е. последней буквы.
Вторым применением lamda-функций является фильтрация различных структур данных. Например, необходимо исключить все четные элементы в списке. Для этого имеется встроенная в Python функция :
>>> nums = >>> even = filter(lambda x: x % 2 == 0, nums) >>> list(even)
принимает первым аргументом функцию, через которую осуществляется фильтрация элементов. В данном случае мы использовали анонимную функцию.
Третий пример – это использование lambda-функций в отображениях нового пространства. Требуется из заданного списка чисел получить список кубов этих чисел. С помощью это будет выглядеть так:
>>> nums = >>> cubes = map(lambda x: x**3, nums) >>> list(cubes)
принимает первым аргументом функцию, отображающую список в новом пространстве. Здесь была использована анонимная функция, которая возводит элемент в 3-ю степень.
Четвертый пример, где используется lambda-функции – это . Если необходимо получить из списка одно значение, то используется из Python-модуля . Получение произведения чисел в списке будет выглядеть следующим образом:
>>> nums = >>> reduce(lambda x, y: x * y, nums) 5040
Алгоритм выполнения reduce можно записать как . Каждый момент итерирования сопровождается обновлением первого аргумента lambda-функции x, таким образом, становясь результатом произведения.
Стоит отметить, не всегда lambda-функции являются уместными из-за их неочевидного интерфейса. Например, и могут быть переписаны через List comprehension, о котором мы говорили тут. Как использовать lambda-функции и List comprehension в реальных проектах Data Science, вы узнаете на наших практических курсах по Python в лицензированном учебном центре обучения и повышения квалификации ИТ-специалистов в Москве.
Смотреть расписание
Записаться на курс
Источники
Строки
Строка – это последовательность символов. Чаще всего строки – это просто некоторые наборы слов. Слова могут быть как на английском языке, так и почти на любом языке мира.
Операции со строками
string извлекает символ в позиции i
string извлекает последний символ
string извлекает символы в диапазоне от i до j
Методы работы сос строками
string.upper() преобразует строку в верхний регистр
String.lower() преобразует в строку в нижний регистр
string.count(x) подсчитывает, сколько раз появляется x
string.find(x) позиция первой строки вхождения x
string.replace(x, y) заменяет x на y
string.strip(x) удаляет как начальные, так и конечные символы x
string.join (List) объединяет список строк
Параметры функции
Только что вы написали простую функцию без параметров: круглые скобки остались пустыми. Теперь попробуйте создать функцию с параметрами.
Параметр – это именованный объект, определяющий аргумент, который может принять функция.
Попробуйте написать простую программу с параметрами x, y и z. Создайте функцию, которая складывает эти параметры и выводит результат. Вызовите функцию и передайте ей числа. Создайте файл add_numbers.py и добавьте в него код:
Параметр x имеет значение 1, y – 2, а z – 3.
Значения присваиваются каждому параметру по порядку.
Программа выполняет следующие вычисления:
Также программа выводит значения a, b и c. Давайте запустим программу и посмотрим на результат:
Параметры – это аргументы, которые в функции определяются как переменные. При запуске метода им можно присваивать значения и передавать их функции.
Замыкание
Функции более высокого порядка не только получают функции на входе, но и могут порождать новые функции на выходе. Они даже в состоянии запоминать ссылку на значение в функции, которую они генерируют. Это называется замыканием. Функция, имеющая замыкание, может «запоминать» и получать доступ к среде вложенных в нее значений.
Используя замыкания, можно разделить исполнение функции со многими аргументами на большее количество шагов. Эта операция называется каррированием и обязана своим названием Хаскелю Каррингу. Каррирование – это преобразование функции многих аргументов в функцию, берущую свои аргументы по одному. Например, предположим, ваш программный код имеет приведенную ниже стандартную функцию :
Чтобы сделать ее каррированной, она должна быть переписана следующим образом:
Это же самое можно выразить при помощи лямбда-функций:
Обратите внимание, что в последнем примере используются две вложенные лямбда-функции, каждая из которых принимает всего один аргумент. В такой записи функция теперь может вызываться всего с одним аргументом
Выражение возвращает не число, а новую, каррированную функцию. Во время вызова функции со значением 3 в качестве первого аргумента ссылка на значение 3 запоминается в каррированной функции. А дальше происходит следующее:
В приведенном выше примере каррированная функция присваивается переменной sum_three, которая теперь на нее ссылается. Если вызвать функцию , передав ей второй аргумент, то она вернет результат сложения двух аргументов 3 и 1.
Замыкания также используются для генерирования набора связанных функций по шаблону. Использование шаблона функции помогает делать программный код более читаемым и избегать дублирования. Давайте посмотрим на приведенный ниже пример:
Функция может применяться для генерации разных функций, которые вычисляют степень:
Отметим, что функции и сохраняют значение переменной . Эта переменная существовала только в среде , несмотря на то, что эти возвращенные функции абсолютно независимы от функции . Напомним еще раз: замыкание – это функция, которая имеет доступ к некоторым переменным за пределами своей собственной среды.
Замыкания могут также использоваться для управления внутренним состоянием функции. Давайте предположим, что требуется функция, которая накапливает сумму всех чисел, которые ей предоставляются. Один из способов это сделать состоит в использовании глобальной переменной:
Как мы убедились, применение глобальных переменных следует избегать, потому что они загрязняют пространство имен программы. Более чистый подход состоит в использовании замыкания, чтобы включить ссылку на накапливающую переменную:
Такой подход позволяет создавать несколько счетчиков без применения глобальных переменных
Обратите внимание, что в этом примере использовано ключевое слово , которое объявляет, что переменная n не является локальной для вложенной функции fn. В приведенном ниже интерактивном сеансе показано, как это работает:
Некоторые языки программирования строго функциональны; весь код эквивалентен чистым математическим функциям. Эти языки заходят настолько далеко, что являются вневременными, причем порядок операторов в программном коде не вмешивается в поведение кода. В этих языках все присвоенные переменным значения являются немутируемыми. Такое присваивание называется однократным. Поскольку состояние программы отсутствует, то и нет момента времени, когда переменная может измениться. Вычисления в строгой функциональной парадигме просто сводятся к вычислению функций и сопоставлению с шаблонами.
