Python и функциональное программирование

Использование * и ** при вызове функции

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

Выход:

name: Jakeposition: data analystemail: 

Выход:

name: Jakeposition: data analystemail: 

Python Исключения

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

Например, мы можем увидеть часть из документации длявстроенная функция: «Вернуть целочисленный объект, построенный из числа или строки x, или returnесли нет аргументов ».

Выход:

67--------------------------------------------------------------------ValueError                         Traceback (most recent call last)<ipython-input-1-dea319bbd9d9> in <module>()      1 print(int(6.99))      2 print(int("7"))----> 3 print(int("Hi"))ValueError: invalid literal for int() with base 10: 'Hi'

Мы можем видеть, чтоValueError повышаетсякогда мы передали строку «Hello» в качестве входных данных.

Разные

ascii()	Он возвращает строку, содержащую печатную форму объекта, и игнорирует значения, отличные от ASCII, в строке	ascii(объект)
bool()	Он возвращает логическое значение, то есть True или False для объекта.	bool(значение)
bytearray()	Он возвращает объект, содержащий массив байтов, предоставленных через ввод	bytearray(источник, кодировка, ошибки)
bytes()	Он возвращает объект байтов, который не может быть изменен и представляет собой последовательность целых чисел в диапазоне от 0 до 255.	bytes(источник, кодировка, ошибки)
enumerate()	Он используется для добавления счетчика к итерируемому объекту, а затем возвращает его значение	enumerate(итерация, начало = 0)
float()	Возвращает число с плавающей запятой из заданного аргумента.	float (аргумент)
hash()	Возвращает хеш-значение объекта, если применимо.	hash(объект)
id()	Он возвращает конкретную идентификацию объекта, которая является уникальным целым числом.	id(объект)
int()	Он возвращает целочисленный объект из заданного ввода, и база возвращаемого объекта всегда будет 10	int (x = 0, основание = 10)
len()	Возвращает длину последовательности, т.е. количество элементов в объекте.	len (последовательность)
map()	Он используется для применения заданной функции к каждому элементу итерации, который может быть кортежем, списком и т. Д., А также возвращает список, содержащий результирующие значения.	map(функция, итерация, …)
ord()	Он принимает строковый аргумент из одного символа Unicode и возвращает его точку уважения Unicode	ord(символ)
print()	Он печатает предоставленный объект на любом устройстве вывода	print (объект (ы), separator = separator, end = end, file = file, flush = flush)
slice()	Он создает объект, который представляет собой набор индексов, заданных его диапазоном (начало, остановка, шаг).	slice (стоп) срез (начало, остановка, шаг)
type()	Возвращает тип объекта	type(объект) тип (имя, базы, dict)

What is a function in Python?

In Python, a function is a group of related statements that performs a specific task.

Functions help break our program into smaller and modular chunks. As our program grows larger and larger, functions make it more organized and manageable.

Furthermore, it avoids repetition and makes the code reusable.

Syntax of Function

def function_name(parameters):
	"""docstring"""
	statement(s)

Above shown is a function definition that consists of the following components.

1. Keyword that marks the start of the function header.
2. A function name to uniquely identify the function. Function naming follows the same .
3. Parameters (arguments) through which we pass values to a function. They are optional.
4. A colon (:) to mark the end of the function header.
5. Optional documentation string (docstring) to describe what the function does.
6. One or more valid python statements that make up the function body. Statements must have the same indentation level (usually 4 spaces).
7. An optional statement to return a value from the function.

How to call a function in python?

Once we have defined a function, we can call it from another function, program or even the Python prompt. To call a function we simply type the function name with appropriate parameters.

Note: Try running the above code in the Python program with the function definition to see the output.

Важные вещи, которые следует отметить

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

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

Если тело вашей функции не имеет отступа, Python будет считать, что вы начали другой оператор:

#editor
def sum(value1, value2):
  sum_of_values = value1 + value2
  return sum_of_values

result = sum(3, 7)
print(result)

#console
IndentationError: expected an indented block

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

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

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

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

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

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

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

ответственность .

Функция должна иметь только одну |||| ответственность || .

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

Сделав это, вы не только улучшите читаемость кода , но и облегчите его тестирование и отладку.

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

Спасибо за чтение! Если у вас все еще есть проблемы с пониманием концепции функций, не беспокойтесь; вот ссылка на Самое простое объяснение функций, которое Вы когда-либо читали .

Я еженедельно делюсь потрясающим контентом по разработке программного обеспечения и веб-разработке на своем канале YouTube. Пожалуйста, проверьте это и подпишитесь здесь .

Нашли это полезным? Пожалуйста, оставьте смайлик , комментарий и поделитесь!

Вот мой недавний подкаст о том, как преуспеть в первый год работы инженером-программистом. Я поделился несколькими своими впечатлениями в области технологий и вещами, которые я хотел бы, чтобы кто-то рассказал мне в течение моего первого года работы инженером-программистом: Как преуспеть в свой первый год работы инженером-программистом

Функциональный стиль в Python

В функциональном программировании вычисления выполняются путем объединения функций, которые принимают аргументы и возвращают конкретное значение (или значения). Эти функции не изменяют свои входные аргументы и не изменяют состояние программы. Они просто предоставляют результат данного вычисления. Такие функции обычно называются чистыми функциями (pure functions).

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

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

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

1. Сопоставление (Mapping) заключается в применении функции преобразования к итерируемому объекту для создания нового объекта. Элементы в новой итерации создаются путем вызова функции преобразования для каждого элемента в исходной итерации.
2. Фильтрация (Filtering) состоит из применения предиката или булевозначной функции (predicate or Boolean-valued function) к итерируемому объекту для создания нового итерируемого объекта. Элементы в новой итерации создаются путем фильтрации любых элементов в исходной итерации, которые заставляют функцию предиката возвращать false.
3. Сокращение (Reducing) состоит из применения функции reduce к итерируемому объекту для получения единственного накопленного значения.

По словам Гвидо ван Россума, на Python в большей степени влияют императивные языки программирования, чем функциональные языки:

Однако еще в 1993 году сообщество Python требовало некоторых функций функционального программирования. Они просили:

• Анонимные функции
• Функцию 
• Функцию  
• Функцию  

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

В этом руководстве мы рассмотрим одну из этих функциональных возможностей — встроенную карту функций map(). Вы также узнаете, как использовать составные части списковых включений (comprehensions) и выражения генератора (generator expressions), чтобы получить ту же функциональность, что и map(), в питоническом и удобочитаемом виде.

Основные строковые функции

capitalize()	Преобразует первый символ строки в верхний регистр	str_name.capitalize()
casefold()	Он преобразует любую строку в нижний регистр независимо от ее регистра	str_name.casefold()
center()	Используется для выравнивания строки по центру	str_name.center (длина, символ)
count()	Для подсчета количества раз, когда определенное значение появляется в строке.	str_name.count (значение, начало, конец)
endswith()	Проверяет, заканчивается ли строка указанным значением, затем возвращает True	str_name.endswith (значение, начало, конец)
find()	Используется для определения наличия указанного значения в строке	str_name.find (значение, начало, конец)
index()	Он используется для поиска первого вхождения указанного значения в строке	str_name.index (значение, начало, конец)
isalnum()	Проверяет, все ли символы являются буквенно-цифровыми, затем возвращает True	str_name.isalnum()
isalpha()	Проверяет, все ли символы являются алфавитными (az), затем возвращает True	str_name.isalpha()
isdecimal()	Проверяет, все ли символы являются десятичными (0-9), затем возвращает True	str_name.isdecimal()
isdigit()	Проверяет, все ли символы являются цифрами, затем возвращает True	str_name.isdigit()
islower()	Проверяет, все ли символы в нижнем регистре, затем возвращает True	str_name.islower()
isnumeric()	Проверяет, все ли символы являются числовыми (0-9), затем возвращает True	str_name.isnumeric()
isspace()	Проверяет, все ли символы являются пробелами, затем возвращает True	str_name.isspace()
isupper()	Проверяет, все ли символы в верхнем регистре, затем возвращает True	str_name.isupper()
lower()	Используется для преобразования всех символов в нижний регистр	str_name.lower()
partition()	Используется для разделения строки на кортеж из трех элементов.	str_name.partition (значение)
replace()	Используется для замены указанного слова или фразы другим словом или фразой в строке.	str_name.replace (старое значение, новое значение, количество)
split()	Используется для разделения строки на список	str_name.split (разделитель, maxsplit)
splitlines()	Используется для разделения строки и составления ее списка. Разбивается на разрыв строки.	str_name.splitlines (keeplinebreaks)
startswith()	Проверяет, начинается ли строка с указанного значения, затем возвращает True	str_name.startswith (значение, начало, конец)
strip()	Используется для удаления символов, указанных в аргументе, с обоих концов	str_name.strip (символы)
swapcase()	Используется для замены строки верхнего регистра на нижний регистр или наоборот.	str_name.swapcase()
title()	Преобразует начальную букву каждого слова в верхний регистр	str_name.title()
upper()	Он используется для преобразования всех символов в строке в верхний регистр	str_name.upper()

*args и **kwargs

Вы также можете настроить функцию на прием любого количества аргументов, или ключевых аргументов, при помощи особого синтаксиса. Чтобы получить бесконечное количество аргументов, мы используем *args, а чтобы получить бесконечное количество ключевых аргументов, мы используем *kwargs. Сами слова “args” и “kwargs” не так важны. Это просто сокращение. Вы можете назвать их *lol и *omg, и они будут работать таким же образом. Главное здесь – это количество звездочек

Обратите внимание: в дополнение к конвенциям *args и *kwargs, вы также, время от времени, будете видеть andkw. Давайте взглянем на следующий пример:

Python

def many(*args, **kwargs):
print( args )
print( kwargs )

many(1, 2, 3, name=»Mike», job=»programmer»)

# Результат:
# (1, 2, 3)
# {‘job’: ‘programmer’, ‘name’: ‘Mike’}

1 2 3 4 5 6 7 8 9

defmany(*args,**kwargs) print(args) print(kwargs) many(1,2,3,name=»Mike»,job=»programmer»)   # Результат: # (1, 2, 3) # {‘job’: ‘programmer’, ‘name’: ‘Mike’}

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

Python Tutorial

Python HOMEPython IntroPython Get StartedPython SyntaxPython CommentsPython Variables
Python Variables
Variable Names
Assign Multiple Values
Output Variables
Global Variables
Variable Exercises

Python Data TypesPython NumbersPython CastingPython Strings
Python Strings
Slicing Strings
Modify Strings
Concatenate Strings
Format Strings
Escape Characters
String Methods
String Exercises

Python BooleansPython OperatorsPython Lists
Python Lists
Access List Items
Change List Items
Add List Items
Remove List Items
Loop Lists
List Comprehension
Sort Lists
Copy Lists
Join Lists
List Methods
List Exercises

Python Tuples
Python Tuples
Access Tuples
Update Tuples
Unpack Tuples
Loop Tuples
Join Tuples
Tuple Methods
Tuple Exercises

Python Sets
Python Sets
Access Set Items
Add Set Items
Remove Set Items
Loop Sets
Join Sets
Set Methods
Set Exercises

Python Dictionaries
Python Dictionaries
Access Items
Change Items
Add Items
Remove Items
Loop Dictionaries
Copy Dictionaries
Nested Dictionaries
Dictionary Methods
Dictionary Exercise

Python If…ElsePython While LoopsPython For LoopsPython FunctionsPython LambdaPython ArraysPython Classes/ObjectsPython InheritancePython IteratorsPython ScopePython ModulesPython DatesPython MathPython JSONPython RegExPython PIPPython Try…ExceptPython User InputPython String Formatting

Функции

Последнее обновление: 11.04.2018

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

def имя_функции ():
    инструкции

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

Например, определение простейшей функции:

def say_hello():
    print("Hello")

Функция называется . Она не имеет параметров и содержит одну единственную инструкцию,
которая выводит на консоль строку «Hello».

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

def say_hello():
    print("Hello")
    
say_hello()
say_hello()
say_hello()

Здесь три раза подряд вызывается функция say_hello. В итоге мы получим следующий консольный вывод:

Hello
Hello
Hello

Теперь определим и используем функцию с параметрами:

def say_hello(name):
    print("Hello,",name)

say_hello("Tom")
say_hello("Bob")
say_hello("Alice")

Функция принимает параметр name, и при вызове функции мы можем передать вместо параметра какой-либо значение:

Hello, Tom
Hello, Bob
Hello, Alice

Значения по умолчанию

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

def say_hello(name="Tom"):
    print("Hello,", name)
	
say_hello()
say_hello("Bob")

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

Именованные параметры

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

def display_info(name, age):
    print("Name:", name, "\t", "Age:", age)
	
display_info("Tom", 22)

При вызове функции первое значение «Tom» передается первому параметру — параметру name, второе значение — число 22 передается второму параметру — age. И так далее по порядку.
Использование именованных параметров позволяет переопределить порядок передачи:

def display_info(name, age):
    print("Name:", name, "\t", "Age:", age)
	
display_info(age=22, name="Tom")

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

Неопределенное количество параметров

С помощью символа звездочки можно определить неопределенное количество параметров:

def sum(*params):
    result = 0
    for n in params:
        result += n
    return result


sumOfNumbers1 = sum(1, 2, 3, 4, 5)		# 15
sumOfNumbers2 = sum(3, 4, 5, 6)			# 18
print(sumOfNumbers1)
print(sumOfNumbers2)

В данном случае функция sum принимает один параметр — , но звездочка перед названием параметра указывает, что фактически на место этого
параметра мы можем передать неопределенное количество значений или набор значений. В самой функции с помощью цикла for можно пройтись по этому набору и произвести с переданными
значениями различные действия. Например, в данном случае возвращается сумма чисел.

Возвращение результата

Функция может возвращать результат. Для этого в функции используется оператор return, после которого указывается возвращаемое значение:

def exchange(usd_rate, money):
    result = round(money/usd_rate, 2)
    return result

result1 = exchange(60, 30000)
print(result1)
result2 = exchange(56, 30000)
print(result2)
result3 = exchange(65, 30000)
print(result3)

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

В Python функция может возвращать сразу несколько значений:

def create_default_user():
    name = "Tom"
    age = 33
    return name, age


user_name, user_age = create_default_user()
print("Name:", user_name, "\t Age:", user_age)

Здесь функция create_default_user возвращает два значения: name и age. При вызове функции эти значения по порядку присваиваются переменным
user_name и user_age, и мы их можем использовать.

Функция main

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

def main():
    say_hello("Tom")
    usd_rate = 56
    money = 30000
    result = exchange(usd_rate, money)
    print("К выдаче", result, "долларов")


def say_hello(name):
    print("Hello,", name)
    
    
def exchange(usd_rate, money):
    result = round(money/usd_rate, 2)
    return result

# Вызов функции main
main()

НазадВперед

Важность функций

Абстракция

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

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

Нам не важно, кто совершает движение: и для человека и для самолёта средняя скорость будет рассчитываться одинаково

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

Возможность повторного использования

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

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

Всего 10 таких сортировок, и привет, лишние 60 строк кода.

Модульность

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

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

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

Без применения модульности получится сплошная последовательность инструкций:

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

Это и называется модульностью.

Пространство имен

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

Пример из жизни: в ВУЗе учатся два человека с совпадающими ФИО. Их нужно как-то различать. Если сделать пространствами имён группы этих студентов, то проблема будет решена. В рамках своей группы ФИО этих студентов будут уникальными.

Определение функции с документацией

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

Выход:

2019-02-1908:26:49.538434

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

• аргументы функции
• вычисления функций
• возвращаемое значение / с

Объем

Не все объекты (включая функции), которые мы определили, доступны везде в нашем коде Python. Объем программы представляетгде имя переменной или имя функции могут быть доступны, Python имеет 3 типа областей действия:местный,Глобальныйа такжевстроенныйобъем.

Мин () Функция

Это встроенная функция в Python 3. Возвращает наименьший предмет в неразмерной или наименьшее из двух или более аргументов.

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

Допустимые аргументы:

min(2, 3)
min()
min('a', 'b', 'c')

Неверные аргументы:

min(2, 'a')
min()
min([])

Возвращаемое значение

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

Образец кода

print(min(2, 3)) # Returns 2 as 2 is the smallest of the two values
print(min(2, 3, -1)) # Returns -1 as -1 is the smallest of the two values

list1 = 
print(min(list1)) # Returns -54 as -54 is the smallest value in the list

list2 = 
print(min(list2)) # Returns 'a' as 'a' is the smallest in the list in alphabetical order

list3 = 
print(min(list3)) # Gives TypeError as values in the list are of different type

#Fix the TypeError mentioned above first before moving on to next step

list4 = []
print(min(list4)) # Gives ValueError as the argument is empty

Запустите код

Официальные документы

Это встроенная функция в Python 3, которая возвращает фактор и остаток при разделении числа по количеству Отказ Требуется два числа в качестве аргументов & Отказ Аргумент не может быть сложным числом.

Возвращаемое значение

Возвращаемое значение будет парой положительных чисел, состоящих из частных и остальных, полученных путем разделения По Отказ В случае смешанных типов операндов будут применены правила двоичных арифметических операторов. Для Целое число аргументов , возвращаемое значение будет таким же, как Отказ Для Рюмименты десятичных чисел , возвращаемое значение будет таким же, как , где Обычно math.floor (A/B) Но может быть 1 меньше, чем это.

Образец кода

print(divmod(5,2)) # prints (2,1)
print(divmod(13.5,2.5)) # prints (5.0, 1.0)
q,r = divmod(13.5,2.5)  # Assigns q=quotient & r= remainder
print(q) # prints 5.0 because math.floor(13.5/2.5) = 5.0
print(r) # prints 1.0 because (13.5 % 2.5) = 1.0

Запретить!

Официальные документы

Функции vs процедуры – в чем отличие?

Для языка нет различий между функциями и процедурами. Но с точки зрения программиста – это разные сущности.

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

Она успешно отработает, но не вернёт нам результат. Поэтому добавляем ключевое слово , и вот этот код обретает смысл:

И наоборот, оформлять набор инструкций, выполняющий некую обработку, в виде функции также лишено смысла:

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