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

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

Синтаксис

Простой пример: Вы торгуете мёдом, и после каждой продажи вам нужно печатать чек. В нём должно быть указано: название фирмы, дата продажи, список наименований проданных товаров, их количество, цены, общая сумма, а также сакраментальная фраза «Спасибо за покупку!».

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

А теперь представьте, что произойдёт, когда вы раскрутитесь, и покупатели станут приходить один за другим. В таком случае, чеки надо будет выдавать очень быстро. Но что делать, если вдруг нагрянет ваш любимый клиент и купит 10 сортов мёда в разных количествах? Далеко не все в очереди согласятся ждать, пока вы посчитаете общую сумму и внесёте её в чек.

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

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

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

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

Логический оператор AND в Python

Вот простой пример логического оператора and.

x = 10
y = 20

if x > 0 and y > 0:
    print('Both x and y are positive numbers')

Вывод: и x, и y – положительные числа.

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

if (x > 0) and (y > 0):
    print('Both x and y are positive numbers')

В Python каждая переменная или объект имеет логическое значение.

if x and y:
    print('Both x and y have boolean value as True')

Вывод: И x, и y имеют логическое значение True, потому что функция len() ‘x’ и ‘y’ вернет 2, т.е.> 0.

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

class Data:
    id = 0

    def __init__(self, i):
        self.id = i

    def __bool__(self):
        print('Data bool method called')
        return True if self.id > 0 else False


d1 = Data(-10)
d2 = Data(10)
if d1 and d2:
    print('Both d1 and d2 ids are positive')
else:
    print('Both d1 and d2 ids are not positive')

Вывод:

Data bool method called
At least one of d1 and d2 ids is negative

Обратите внимание, что функция __bool __() вызывается только один раз, что подтверждается выводом оператора печати. На диаграмме ниже изображена логическая блок-схема и схема работы

На диаграмме ниже изображена логическая блок-схема и схема работы.

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

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

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

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

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

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

Переменные внутри функции – локальные. Поиск переменных: сперва среди локальных, потом среди глобальных.

Рассмотрим следующую функцию:

def func():
    a = []
    for i in range(5):
        a.append(i)

При вызове func() создается пустой список a, в него добавляется 5 элементов, а затем, когда функция завершается, список a уничтожается. Но допустим, что мы объявили a следующим образом:

a = []
def func():
    for i in range(5):
        a.append(i)

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

a = None

def bind_a_variable():
    global a
    a = []

bind_a_variable()
print a

Результат:

[]

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

def outer_function(x, y, z):
    def inner_function(a, b, c):
        pass
    pass

Здесь функция inner_function не существует, пока не вызвана функция outer_function. Как только outer_function завершает выполнение, inner_function уничтожается.

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

Строго говоря, любая функция локальна в какой-то области видимости, хотя это может быть и область видимости на уровне модуля.

1. Lambda-функции

В этом уроке мы изучим, что из себя представляют lambda-функции в Python с их синтаксисом и примерами. Кроме того, мы рассмотрим, как и когда следует объявлять lambda-функции, а также как их можно использовать вместе со встроенными функциями Python такими как reduce(), map() и filter(). 

Когда мы создаем функции в Python, мы всегда используем ключевое слово def. При этом, делая так, мы назначаем им определенное имя. Но иногда у нас может возникнуть потребность объявить функцию анонимно или мы можем захотеть использовать функцию только один раз. В таком случае определение функции может показаться лишним, и как раз здесь нам придут на помощь lambda-функции.

Именованные аргументы

Параметры можно вызывать не только ко порядку. Именованные аргументы позволяют вызывать параметры по имени.

При этом параметры можно вызывать в том порядке, в котором они определены. Интерпретатор Python будет использовать имя параметра для поиска требуемого значения.

Создайте функцию, которая будет выводить информацию о профиле пользователя. Откройте файл profile.py и передайте ей параметры username (строка) и followers (целое число).

В определении функции profile_info() параметры username и followers взяты в круглые скобки. Блок функции выводит строку с информацией о пользователе на основе двух параметров.

Вызовите функцию и присвойте ей параметры:

В первом вызове используется имя 8hostblog с количеством подписчиков 945. Во втором вызове используется именованные аргументы.

Запустите программу:

В выводе вы видите имя и количество подписчиков каждого пользователя.

Вы можете изменить порядок отображения параметров в этой программе:

Попробуйте снова запустить программу. Вы получите такой результат:

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

Лямбда-функции Python

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

lambda value1, value2: value1 + value2

Несколько вещей, которые следует отметить:

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

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

#editor
list_of_numbers = 
halved_list = list(map(lambda value: value/2 , list_of_numbers)) 

print(halved_list)

#console
halved list: 

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

#editor
sum = lambda value1, value2: value1 + value2
result = sum(7, 9)

print(result)

#console
16

Операции со строками

Строки в Python неизменяемые, вы не можете изменить один из символов строки. Любое изменение содержимого требует создания новой копии. Откройте интерпретатор и выполняйте перечисленные ниже примеры, для того чтобы лучше усвоить все написанное:

3. Объединение с преобразованием

Вы можете объединить строку с числом или логическим значением. Но для этого нужно использовать преобразование. Для этого существует функция str():

4. Поиск подстроки

Вы можете найти символ или подстроку с помощью метода find:

Этот метод выводит позицию первого вхождения подстроки losst.ru если она будет найдена, если ничего не найдено, то возвращается значение -1. Функция начинает поиск с  первого символа, но вы можете начать с энного, например, 26:

В этом варианте функция вернет -1, поскольку строка не была найдена.

5. Получение подстроки

Мы получили позицию подстроки, которую ищем, а теперь как получить саму подстроку и то, что после нее? Для этого используйте такой синтаксис , просто укажите два числа или только первое:

Первая строка выведет подстроку от первого до второго символа, вторая — от второго и до конца

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

Вы можете заменить часть строки с помощью метода replace:

Если вхождений много, то можно заменить только первое:

7. Очистка строк

Вы можете удалить лишние пробелы с помощью функции strip:

Также можно удалить лишние пробелы только справа rstrip или только слева — lstrip.

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

9. Конвертирование строк

Есть несколько функций для конвертирования строки в различные числовые типы, это int(), float() , long() и другие. Функция int() преобразует в целое, а float() в число с плавающей точкой:

10. Длина строк

Вы можете использовать функции min(), max(), len() для расчета количества символов в строке:

Первая показывает минимальный размер символа, вторая — максимальный, а третья — общую длину строки.

11. Перебор строки

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

Для ограничения цикла мы использовали функцию len()

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

Список

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

Создание пустого списка

numbers = [] 

Создание списка чисел:

numbers =  # имя списка numbers, он содержит 5 элементов

Создание списка слов:

words =  # имя списка words, он  содержит 4 элемента

Создание списка из элементов разного типа

listNum =  # имя списка listNum,    список     содержит целые числа и строки

Для управления элементами списки имеют целый ряд методов. Некоторые из них:

append(item): добавляет элемент item в конец списка

insert(index, item): добавляет элемент item в список по индексу index

remove(item): удаляет элемент item. Удаляется только первое вхождение элемента. Если элемент не найден, генерирует исключение ValueError

clear(): удаление всех элементов из списка

index(item): возвращает индекс элемента item. Если элемент не найден, генерирует исключение ValueError

pop(): удаляет и возвращает элемент по индексу index. Если индекс не передан, то просто удаляет последний элемент.

count(item): возвращает количество вхождений элемента item в список

sort(): сортирует элементы. По умолчанию сортирует по возрастанию. Но с помощью параметра key мы можем передать функцию сортировки.

reverse(): расставляет все элементы в списке в обратном порядке

Кроме того, Python предоставляет ряд встроенных функций для работы со списками:

len(list): возвращает длину списка

sorted(list, ): возвращает отсортированный список

min(list): возвращает наименьший элемент списка

Каррирование: частичное фиксирование аргументов функции

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

Пусть, например, имеется тривиальная функция сложения двух чисел:

def add_numbers(x, y):
    return x + y

Мы можем породить на ее основе новую функцию одной переменной, add_five, которая прибавляет к своему аргументу 5:

add_five = lambda y: add_numbers(5, y)

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

Теперь запустим полный код:

def add_numbers(x, y):
    return x + y

add_five = lambda y: add_numbers(5, y)

print(add_five(10))

Результат:

15

Стандартный модуль functools упрощает эту процедуру за счет функции partial:

from functools import partial

def add_numbers(x, y):
    return x + y

add_five = partial(add_numbers, 5)

print(add_five(10))

Также вернет

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

# вычислить скользящее среднее временного ряда x за 60 дней
ma60 = lambda x: pandas.rolling_mean(x, 60)
# вычислить скользящие средние за 60 дней всех временных рядов в data
data.apply(ma60)

5
1
голос

Рейтинг статьи

*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 – в словарь. Вы встретите такой тип кодинга, если взгляните на исходный код Пайтона, или в один из сторонних пакетов Пайтон.

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

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

#editor
def example_function():
  word = "inevitable"
  return word

print(word)

#console
NameError: name 'word' is not defined

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

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

#editor
word = "inevitable"
def example_function():
  return word

print(word)

#console
inevitable

Python рекурсивная функция

Когда функция вызывает сама, это называется рекурсивной функцией. Этот сценарий называется рекурсией в программировании.

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

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

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

5.1.1. Основные понятия и механизм работы¶

Подпрограмма должна быть объявлена и в общем случае содержать:

• имя;

• список имен и типов передаваемых параметров (необязательно);

• тип возвращаемого значения (необязательно).

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

Большинство современных языков программирования для управления вызовом подпрограмм используют стек вызовов.

Примерный цикл работы стека вызова следующий (Видео 5.1.1, Видео 5.1.2):

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

2. Когда подпрограмма завершается, запись удаляется из стека и программа продолжает выполняться, начиная с адреса возврата.

Видео 5.1.1 — Cтек вызовов (пример, Нетология)

Your browser does not support the video tag.

Видео 5.1.2 — Cтек вызовов (пример, Stepik.org)

Когда лучше использовать lambda-функцию в Python?

Как мы видели ранее, lambda-функция в Python может принимать несколько аргументов и одно выражение. Причем значение этого выражения как раз и есть то, что возвращается при вызове функции. Использование lambda-функций не является обязательным, но может оказаться полезным в определенных ситуациях. Таких, например как:

1. Когда у вас есть только одно выражение для исполнения в функции

Допустим, мы хотим для функции printhello() запрограммировать вывод на экран слова «Привет». Тогда в теле функции у нас будет всего одна строчка:

def printhello():
    print("Привет")
printhello()

Привет

Теперь давайте сделаем то же самое, используя lambda-функцию.

(lambda :print("Привет"))()

Привет

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

z=lambda a=2:print("Hello")
z()

Привет

2. Когда нужно вызвать код только один раз

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

Функция Python Переменные аргументы

Python позволяет три типа параметров в определении функции.

1. Формальные аргументы: те, которые мы видели в примерах до сих пор.
2. Переменная числа аргументов без ключевых слов: например, Def Добавить (* args)
3. Переменная Количество аргументов ключевых слов или названные аргументы: Например, Def Добавить (** kwargs)

Некоторые важные моменты о переменных аргументах в Python являются:

• Заказ аргументов должен быть формальными аргументами, * args, а ** кварги.
• Не обязательно использовать переменные имена параметров в качестве ARGS и KWARGS. Тем не менее, это лучшая практика, чтобы использовать их для лучшей читаемости кода.
• Тип args кортеж. Таким образом, мы можем пройти кортеж, чтобы быть сопоставленным с * args variable.
• Тип кварг – это дикт. Таким образом, мы можем передать словарь, чтобы быть сопоставленным с ** kwargs переменной.

Вот простой пример использования переменных аргументов в функции.

def add(x, y, *args, **kwargs):
    sum = x + y
    for a in args:
        sum += a

    for k, v in kwargs.items():
        sum += v
    return sum


total = add(1, 2, *(3, 4), **{"k1": 5, "k2": 6})
print(total)  # 21

Функции являются объектами

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

states = 

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

Первая попытка могла бы выглядеть так:

import re # Модуль регулярных выражений

def clean_strings(strings):
    result = []
    for value in strings:
        value = value.strip()
        value = re.sub('', '', value) # удалить знаки препинания
        value = value.title()
        result.append(value)
    return result

states = 

states = clean_strings(states)

print(states)

Результат:

Другой подход, который иногда бывает полезен, – составить список операций, которые необходимо применить к набору строк:

import re # Модуль регулярных выражений

def remove_punctuation(value):
    return re.sub('', '', value)

def clean_strings(strings, ops):
    result = []
    for value in strings:
        for function in ops:
            value = function(value)
        result.append(value)
    return result

clean_ops = 
states = 

states = clean_strings(states, clean_ops)

print(states)

Результат:

Подобный функциональный подход позволяет задать способ модификации строк на очень высоком уровне. Степень повторной используемости функции clean_strings определенно возросла!

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

import re # Модуль регулярных выражений

def remove_punctuation(value):
    return re.sub('', '', value)

states = 

states = list(map(remove_punctuation, states))
states = list(map(str.strip, states))
states = list(map(str.title, states))

print(states)

Результат:

Синтаксис lambda-функции в Python

Мы уже посмотрели, как объявляетcя lambda-функция в Python, но, как и все, что состоит из частей, ее объявление предполагает различные варианты. Так давайте же посмотрим, что мы можем, а что не можем делать с lambda-функцией.

a. Аргументы в Python

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

a,b=1,2
y=lambda a,b:a+b
y()

Traceback (most recent call last):
File “<pyshell#167>”, line 1, in <module>
y()
TypeError: <lambda>() missing 2 required positional arguments: ‘a’ and ‘b’

Здесь отсутствуют значения и a и b

y=lambda a:a+b
y()

Traceback (most recent call last):
File “<pyshell#169>”, line 1, in <module>
y()
TypeError: <lambda>() missing 1 required positional argument: ‘a’

У переменной a все еще отсутствует значение

y=lambda :a+b
y()

3

Наконец здесь, так как нет аргументов с отсутствующим значением, все отлично работает. 

Рекомендуем ознакомиться со статьями Ошибки и Исключения в Python(англ.) и Как исправить ошибки в Python (англ.).

b. Пропускаем аргументы

Указывать аргументы в lambda-функции не обязательно. Она отлично работает и без них.

y=lambda :2+3
y()

5

Во втором примере давайте в качестве выражения используем функцию print()

(lambda :print("Привет"))()

Привет

Вывод напрашивается сам собой, — пропуск аргументов в lambda-функции является вполне приемлемым.

c. Пропускаем выражение

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

y=lambda a,b: 

SyntaxError: invalid syntax

Ясное дело ничего не сработало, да и почему оно должно было сработать, если значение выражение это как раз и есть то, что функция возвращает? Без выражения функция не имеет никакого смысла.

Defining a Function

You can define functions to provide the required functionality. Here are simple rules to define a function in Python.

• Function blocks begin with the keyword def followed by the function name and parentheses ( ( ) ).

• Any input parameters or arguments should be placed within these parentheses. You can also define parameters inside these parentheses.

• The first statement of a function can be an optional statement — the documentation string of the function or docstring.

• The code block within every function starts with a colon (:) and is indented.

• The statement return exits a function, optionally passing back an expression to the caller. A return statement with no arguments is the same as return None.

Функции Python 3 — именованные аргументы

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

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

Создадим Python математическую функцию, которая будет отображать информацию о профиле пользователя. Передадим параметры в функцию в виде username (строка) и followers (число).

profile.py
# Определяем функцию с параметрами
def profile_info(username, followers):
    print("Имя Username: " + username)
    print("Followers: " + str(followers))

В определении функции username и followers находятся в скобках. Блок функции выводит информацию о пользователе в виде строк с применением двух параметров.

Теперь можем вызвать функцию и назначить ей параметры:

profile.py
def profile_info(username, followers):
    print("Имя Username: " + username)
    print("Followers: " + str(followers))

# Вызываем функцию с указанными выше параметрами
profile_info("sammyshark", 945)

# Вызываем функцию с именованными аргументами
profile_info(username="AlexAnglerfish", followers=342)

При первом вызове функции Python мы ввели имя пользователя sammyshark и его 945 подписчиков. При втором вызове функции мы использовали именованные аргументы, присваивая значения переменным аргументов.

Запускаем программу:

python profile.py

Результат
Username: sammyshark
Followers: 945
Username: AlexAnglerfish
Followers: 342

В результате получаем имена пользователей и количество их подписчиков.

Из следующего примера видим, что для той же программы, но с другим вызовом, можно менять последовательность параметров:

profile.py
def profile_info(username, followers):
    print("Имя Username: " + username)
    print("Followers: " + str(followers))

# Изменяем последовательность параметров
profile_info(followers=820, username="cameron-catfish")

Снова запустив программу, получаем следующее:
Результат
Username: cameron-catfish
Followers: 820

При использовании именованных  аргументов функции Python последовательность их передачи при вызове функции не имеет значения.

Variable-length Arguments

You may need to process a function for more arguments than you specified while defining the function. These arguments are called variable-length arguments and are not named in the function definition, unlike required and default arguments.

Syntax for a function with non-keyword variable arguments is given below −

def functionname( *var_args_tuple ):
   "function_docstring"
   function_suite
   return 

An asterisk (*) is placed before the variable name that holds the values of all nonkeyword variable arguments. This tuple remains empty if no additional arguments are specified during the function call. Following is a simple example −

#!/usr/bin/python3

# Function definition is here
def printinfo( arg1, *vartuple ):
   "This prints a variable passed arguments"
   print ("Output is: ")
   print (arg1)
   
   for var in vartuple:
      print (var)
   return

# Now you can call printinfo function
printinfo( 10 )
printinfo( 70, 60, 50 )

When the above code is executed, it produces the following result −

Output is:
10
Output is:
70
60
50

Функции

Функция – это часть кода, принимающая аргументы и возвращающая вычисленное значение. Аргумент – это объект, отправляемый в функцию. Аргументом может быть какое-нибудь значение или ссылка на него.

функции языка программирования Python

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

— def <имя функции> (): — после определения функции ставиться двоеточие, аргументы функции заключаются в круглые скобки. После двоеточия идет со следующей строки отступ и тело функции.

Для выхода из функции используется оператор return, который возвращает значения. Если оператор return не указан, то произойдет возврат значения None.

Функции бывают встроенные и пользовательские. В интерпретаторе Python есть ряд часто используемых функций. Они всегда доступны и можно посмотреть документацию с их описанием и примерами применения. Например, при помощи функции input () можно ввести данные с клавиатуры, а при помощи функции print () вывести данные в консоль. Так, print (“Hello, World!”) выводит строку «Hello, World!».

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

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

Учебники и сайты

Byte of Python от К. Сварупа подойдет для людей, не имеющих опыта программирования.
Читать Укус питона (на русском).

After Hours Programming Python 3 Tutorial . Этот учебник создан для того, чтобы научить основам языка программирования на Python и объяснить, как создавать веб-приложения

Ask Python Учебник по Python для совсем начинающих.

Classpert — Python — большая коллекция бесплатных и платных онлайн-курсов Python от разных авторов.

Hackr.io — лучшие уроки и курсы Python от сообщества программистов.

Hands-on Python Tutorial  — основы Python, графика и простые клиент/серверные взаимодействия (с видеоуроками).

Learning to Program Введение в программирование для тех, кто никогда раньше не программировал, от Алана Голда. В руководстве представлено несколько языков программирования, но особое внимание уделено Python (Python 2 и 3).

Letsfindcourse ` Python: лучшие учебники и курсы по Python, рекомендованные экспертами.

The Wikibooks Non-Programmer’s Tutorial for Python руководство по Python для НЕпрограммистов от Джоша Кольяти.

Изучите Python Вводное руководство для начинающих о Python (с последующим углубленным изучением).

Обучение программированию Алана Голда

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

Python Tutorial in Python’s documentation set. Написано не для НЕрограммистов, но дает представление о вкусе и стиле языка.

The Python-Course.eu’s extensive tutorial for complete beginners — учебник для начинающих с большим количеством иллюстраций.

Pythonspot Tutorials учебники по Python для разных уровней.

The Python Guru — руководство для начинающих программистов.

Top Courses to Learn Python—руководства по Python, представленные и оцененные разработчиками Python (с топом лучших).