# ФУНКЦИИ В Python

#
#
#
# ОПРЕДЕЛЕНИЕ ФУНКЦИИ
#
# Функция в python - объект, принимающий аргументы и возвращающий значение.
# Обычно функция определяется с помощью инструкции def.
# Для определения функции нужно всего лишь написать ключевое слово def перед ее
именем, а после — поставить двоеточие.
# Следом идет блок инструкций.
#
# пример простой функции:
#
def compute_surface(radius):
from math import pi
return pi * radius * radius
#
#
def add(x, y):
return x + y
#
# Последняя строка в блоке инструкций может начинаться с return, если нужно вернуть
какое-то значение.
# Если инструкции return нет, тогда по умолчанию функция будет возвращать объект
None.
# пример:
#
i = 0
def increment():
global i
i += 1
#
# Функция инкрементирует глобальную переменную i и возвращает None (по умолчанию).
#
#
# ВЫЗОВ ФУНКЦИИ

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

surface = compute_surface(1.)
add(1, 10)
#
# Для вызова функции, которая ничего не возвращает:
increment()
#
#
# ЕЩЁ
#
# Функцию можно записать в одну строку, если блок инструкций представляет собой
простое выражение:
def sum(a, b): return a + b
#
# Функции могут быть вложенными:
def func1(a, b):

def inner_func(x):
return x*x*x

return inner_func(a) + inner_func(b)

#
#
# ИНСТРУКЦИЯ return
#
# Функция может быть любой сложности и возвращать любые объекты (списки, кортежи, и
даже функции!):
def newfunc(n):
def myfunc(x):
return x + n
return myfunc
#
# Функция может и не заканчиваться инструкцией return, при этом функция вернет
значение None:
def func():
pass
#
# АРГУМЕНТЫ И ПАРАМЕТРЫ
#
# В функции можно использовать неограниченное количество параметров,
# но число аргументов должно точно соответствовать параметрам.
# Эти параметры представляют собой позиционные аргументы.
# Также Python предоставляет возможность определять значения по умолчанию,
# которые можно задавать с помощью аргументов-ключевых слов.
#
# Параметр — это имя в списке параметров в первой строке определения функции.
# Он получает свое значение при вызове.
#
# Аргумент — это реальное значение или ссылка на него, переданное функции при
вызове.
#
# В этой функции:
def sum(x, y):
return x + y
# x и y — это параметры
#
#а в этой:
sum(1, 2)
# 1 и 2 — аргументы.
#
# Функция может принимать произвольное количество аргументов или не принимать их
вовсе.
# Также распространены функции с произвольным числом аргументов,
# функции с позиционными и именованными аргументами, обязательными и
необязательными.
def func(a, b, c=2): # c - необязательный аргумент
return a + b + c
#
print( func(1, 2) ) # a = 1, b = 2, c = 2 (по умолчанию)
print( func(1, 2, 3) ) # a = 1, b = 2, c = 3
print( func(a=1, b=3) ) # a = 1, b = 3, c = 2
print( func(c=6, a=3, b=35) ) # так - порядок не будет иметь значения
#
# Сначала нужно указывать все позиционные аргументы, а только потом необязательные
# При вызове функции с аргументами по умолчанию можно указать один или несколько,
# и порядок не будет иметь значения
print( func(a=3, c=6) ) # a = 3, c = 6, b не определен = ошибка
# print(func(3, , 6) ) # a = 3, c = 6, b не определен = ошибка
# обойти эту проблему, можно использовать словарь:
params = {'a':10, 'b':20}
S = func(**params)
print( S )
#
#
# УКАЗАНИЕ ПРОИЗВОЛЬНОГО КОЛИЧЕСТВА АРГУМЕНТОВ
#
# Функция также может принимать переменное количество позиционных аргументов, тогда
перед именем ставится *:
def func(*args):
return args
#
d = func(1,2,3,4,5,6,7,8,9)
print(d) # (1, 2, 3, 4, 5, 6, 7, 8, 9)
#
# Как видно из примера, *args - это кортеж из всех переданных аргументов функции,
# и с переменной можно работать также, как и с кортежем.
#
def func(*args):
return args
#
d = func(1,2,3,4,5,6,7,8,9)
print(d) # (1, 2, 3, 4, 5, 6, 7, 8, 9)
#
x,y,*z = d
print(x,y,z) # 1 2 [3, 4, 5, 6, 7, 8, 9]
#
#
# Python обрабатывает позиционные аргументы следующим образом:
# подставляет обычные позиционные аргументы слева направо,
# а затем помещает остальные позиционные аргументы в кортеж (*args),
# который можно использовать в функции.
#
def func(x,y,z,*args):
return x,y,z, args

d = func(1,2,3,4,5,6,7,8,9)
print(d) # (1, 2, 3, (4, 5, 6, 7, 8, 9))
#
#
def add_func(x, *args):
return x + sum(data)/float(len(data))

res = add_func(1,2,3,4,5,6,7,8,9)
print(res) # 6.5
#
res = add_func(10,0,1,2,-1,0,-1,1,2)
print(res) # 10.5
#
# Функция может принимать и произвольное число именованных аргументов,
# тогда перед именем ставится **
# Передавать функции неограниченное количество именованных аргументов :
def func(**args):
return args

d = func(arg1=1, arg2=2, arg3=3)

print(d) # {'arg1': 1, 'arg2': 2, 'arg3': 3}
#
# Теперь в переменной **args у нас хранится словарь,
# с которым мы, опять-таки, можем делать все, что нам заблагорассудится.
#
#
# ПРОИЗВОЛЬНОЕ КОЛИЧЕСТВО АРГУМЕНТОВ-КЛЮЧЕВЫХ СЛОВ
#
# с позиционными аргументами можно определять произвольное количество именованных
аргументов
def func(x,y,z,*args,**kwargs):
return x,y,z, args, kwargs

d = func(1,2,3,4,5,6,7,8,9,arg1=1, arg2=2, arg3=3, a='python' )

print(d) #(1, 2, 3, (4, 5, 6, 7, 8, 9), {'arg1': 1, 'arg2': 2, 'arg3': 3,
'a': 'python'})
#
# Python обрабатывает аргументы-ключевые слова следующим образом:
# подставляет обычные позиционные аргументы слева направо,
# а затем помещает другие позиционные аргументы в кортеж (*args), который сможет
использовать функция
# в конце концов, он добавляет все лишние аргументы в словарь (**kwargs), который
сможет использовать функция.
# например:
def print_mean_sequences(**kwargs):
print (kwargs)
def mean(data):
return sum(data)/float(len(data))
for k,v in kwargs.items():
print (k, mean(v))

print_mean_sequences(x=[1,2,3], y=[3,3,0])
#
#
# ДОКУМЕНТИРОВАНИЕ ФУНКЦИЙ
#
# Определим функцию:
def sum(s,y): return x + y
#
# Если написать и нажать точку в выпадающем списке обнаружится скрытый метод
# (который начинается с двух знаков нижнего подчеркивания), __doc__
# Он нужен для настройки документации функции.
# Документация в Python называется docstring
# и может быть объединена с функцией следующим образом:
def sum(x, y):
"""Первая срока - заголовок

Затем следует необязательная пустая строка и текст

документации.
"""
return x+y

print(sum.__doc__)
#
# Команда docstring должна быть первой инструкцией после объявления функции.
# Ее потом можно будет извлекать или дополнять:
sum.__doc__ += "some additional text"
print(sum.__doc__)

Есть и другие :
print(sum.__name__)
print(sum.__module__)
print(sum.__class__)
print(sum.__dir__)
print(sum.__repr__)
print(sum.__sizeof__)
#
#
# АНОНИМНЫЕ ФУНКЦИИ ( lambda )
#
# Прежде чем переходить как разбору понятия лямбда в Python,
# попробуем понять, чем является обычная функция Python на более глубоком уровне.
# Как вы знаете, все в Python является объектом.
# Например, когда мы запускаем эту простейшую строку кода:
x = 5
# Создается объект Python типа int, который сохраняет значение 5.
# x же является символом, который ссылается на объект.
#
# Теперь проверим тип x и адрес, на которой он ссылается.
# Это можно сделать с помощью встроенных функций type и id.
print( type(x) ) # <class 'int'>
print( id(x) ) # 1631430640
# В итоге x ссылается на объект типа int,
# а расположен он по адресу, который вернула функция id.
#
# А что происходит при определении вот такой функции:
def f(x):
return x * x
# Повторим упражнение и узнаем type и id объекта f.
print( type(f) ) # <class 'function'>
print( id(f) ) # 46539944
#
# Оказывается, в Python есть класс function,
# а только что определенная функция f — это его экземпляр.
# Так же как x был экземпляром класса integer.
# Другими словами, о функциях можно думать как о переменных.
# Разница лишь в том, что переменные хранят данные, а функции — код.
# Это же значит, что функции можно передать в качестве аргументов другим функциям
# или даже использовать их как тип возвращаемого значения.
#
# Рассмотрим простой пример, где функция f передается другой функции.
def modify_list(L, fn):
for idx, v in enumerate(L):
L[idx] = fn(v)
# Итак, modify_list — это функция, которая принимает список L и функцию fn в
качестве аргументов.
# Затем она перебирает список элемент за элементом и применяет функцию к каждому из
них.
# Так, если передать в modify_list функцию f,
# то результатом станет список, где все значения будут возведены в квадрат.
L = [1, 3, 2]
modify_list(L, f)
print(L) # [1, 9, 4]
# Но можно передать и любую другую, которая изменит оригинальный список другим
способом.
# Это очень мощный инструмент.

# Лямбда в Python — это просто еще один способ определения функции.

# Вот базовый синтаксис лямбда-функции в Python:
# lambda arguments: expression
# Используя ключевое слово lambda, мы указываем на то, что собираемся объявить
лямбда-функцию.
# Затем следует перечисление соответствующих параметров, число которых может быть
от нуля до множества.
# После двоеточия мы указываем выражение, которое будет вычислять лямбда-функция.
# Возвращаемое значение — значение, которому присвоена функция.
#
# Например, если нужно определить функцию f из примера выше, то это можно сделать
вот так:
# Объявление лямбда-функции
f = lambda x: x * x
# сначала объявляем лямбда-функцию и присваиваем ее переменной
# присвоение лямбда-функции переменной является
# одним из примеров неправильного ее использования,
# характерного для некоторых программистов
# только в качестве примера
# Узнаем type и id объекта f.
print( type(f) ) # <class 'function'>
print( id(f) ) # 46540088 адрес уже другой (другая функция)
# Вызов лямбда-функции
print( f(5) ) # 25
# Передать в modify_list функцию f
L = [1, 3, 2]
modify_list(L, f)
print(L) # [1, 9, 4]
#
#
# Лямбда с несколькими аргументами
#
# чтобы определить лямбда-функцию с несколькими аргументами
# то достаточно лишь разделить значения запятыми
f = lambda x, y: x * y
print( f(5, 2) ) # 10
#
# Лямбда-функция без аргументов
#
#Допустим, нужно создать функцию без аргументов, которая бы возвращала True:
f = lambda: True
print( f() ) # True
#
# Несколько лямбда-функций
#
# вопрос: а можно ли иметь лямбда-функцию из нескольких строк?
# ответ однозначен: нет.
# Лямбда-функции в Python всегда принимают только одно выражение.
# Если же их несколько, то лучше создать обычную функцию.
#
#
#
# 1. Сортировка последовательности данных
# при помощи встроенной функции sort() / sorted()
# Создание последовательности данных
family = [{'name': 'Natalia', 'birth_year': 73},
{'name': 'Dasha', 'birth_year': 98},
{'name': 'Alex', 'birth_year': 70}]
print( family )
#
# [{'name': 'Natalia', 'birth_year': 73},
# {'name': 'Dasha', 'birth_year': 98},
# {'name': 'Alex', 'birth_year': 70}]
#
# Сортировка
family.sort(key=lambda x: x['name'])
#family = sorted(family, key=lambda x: x['name'])
print( family )
#
# [{'name': 'Alex', 'birth_year': 70},
# {'name': 'Dasha', 'birth_year': 98},
# {'name': 'Natalia', 'birth_year': 73}]
#
# Сортировка по 'birth_year'
family.sort(key=lambda x: x['birth_year'])
print( family )
#
# [{'name': 'Alex', 'birth_year': 70},
# {'name': 'Natalia', 'birth_year': 73},
# {'name': 'Dasha', 'birth_year': 98}]
#
# В выше описанном фрагменте кода мы создали две лямбда-функции в двух вызовах
sorted().
# В каждом из них лямбда определяет аргумент key
# и при каждой операции применяется к каждому элементу объекта списка.
# В нашем случае элементы являются словарями, и, когда нужно провести сортировку по
имени,
# мы используем квадратную скобку, чтобы получить значение ключа name.
#
#
# 2. Нахождение минимальных и максимальных значений
# при помощи встроенной функции () / max()
family = [{'name': 'Natalia', 'birth_year': 73},
{'name': 'Dasha', 'birth_year': 98},
{'name': 'Alex', 'birth_year': 70}]
print( family )
#
# [{'name': 'Natalia', 'birth_year': 73},
# {'name': 'Dasha', 'birth_year': 98},
# {'name': 'Alex', 'birth_year': 70}]
#
# Получение min / max по 'birth_year'
a = min(family,key=lambda x: x['birth_year'])
print( a )
#
# {'name': 'Alex', 'birth_year': 70}
#
a = max(family,key=lambda x: x['birth_year'])
print( a )
#
# {'name': 'Dasha', 'birth_year': 98}
#
#
#
# 3. Использование в качестве фабричной функции
#
# помимо встроенного типа словаря dict,
# в нашем распоряжении есть еще другой словарь под названием defaultdict
# Этот класс является подклассом типа dict, который доступен в модуле collections.
# Конструктор defaultdict представляет собой defaultdict([default_factory[, ...]]).
# default_factory вызывается для создания значения при условии,
# что в словаре еще нет заданного ключа.
#
from collections import defaultdict
# Создание defaultdict

#
# points = defaultdict(lambda: (0, 0), dict()) так тоже работает
points = defaultdict(lambda: (0, 0))
print( points )
points['first'] = 1, 2
points['second'] = 2, 3
points['third'] = 3, 4
points['fourth'] = 4, 5
points['fifth'] = 5, 6
points['sixth'] = 6, 7
points['seventh'] = 7, 8
points['eighth'] = 8, 9
points['ninth'] = 9, 10
points['tenth'] = 10, 1
print( ' ' )
print( points['first'] )
print( points['second'] )
print( points['fourth'] )
print( points['eighth'] )
print( points['tenth'] )
#
# Обратите внимание, что в качестве default_factory
# была установлена лямбда lambda: (0, 0).
# Таким образом, если defaultdict не имеет конкретного ключа,
# она вызывает лямбда-функцию и возвращает значение по умолчанию (0, 0).
#
#
#
# 4. Использование лямбда с функциями высшего порядка
# Важно помнить, что всё в Python является объектом, включая функции.
# Функции, принимающие другие функции в качестве аргументов
# или возвращающие их в качестве результата, называются функциями высшего порядка.
# map() принимает отображающую функцию и применяет ее к одному или более
итерируемым объектам.
# filter() принимает функцию фильтрации и применяет ее к только одному итерируемому
объекту.
#
# Создание списка чисел
def f(x):
return x * x
num1 = [1, 2, 3, 4]
num2 = [5, 6, 7, 8, 9]
# print(num1)
# print(num2)
# Создание списка чисел, каждое из которых умножается на 3
# print(list(map(lambda x: x * 3, num1 )) )
# print(list(map(lambda x: x * 3, num2 )) )
#
# эначения списка num1 умножается на значения списка num2
# print(list(map(lambda x,y: x * y, num1,num2)))
#
# варианты использования функции def f(x) в лямбда
# print( list( map( lambda x:f(x),num2 ) ) ) # [25, 36, 49, 64, 81]
# print( list( map( lambda x,y: y+f(x), num1,num2 ) ) ) # [6, 10, 16, 24]
# print( list( map( lambda x:f(x),num1 ) ) ) # [1, 4, 9, 16]
# print( list( map( lambda x:f(x),num2 ) ) ) # [25, 36, 49, 64,
81]
# print( list( map( lambda x,y:f(x)+f(y),num1 ,num2 ) ) ) # [26, 40, 58, 80]
#
#
# результат v % 2 равен 0 (ноль) число чётное / равен 1 (один) число не чётное
# Создание списка четных чисел if x % 2 == 0
# Создание списка нечетных чисел if x % 2 == 1
def evenness(x):
g = lambda x: (x % 2 and False )or(x % 2 and True )
return g(x)
#
print("Создание списка не четных чисел")
odd_numbers = list(n for n in num1 if n % 2 == 1)
print(odd_numbers)

odd_numbers = list(x for x in num1 if evenness(x))

print(odd_numbers)

odd_numbers = list(filter(lambda x: x%2 == 1, num1))

print(odd_numbers)

odd_numbers = list(filter(lambda x: evenness(x), num1))

print(odd_numbers)
print("----")

print("Создание списка четных чисел")

odd_numbers = list(n for n in num1 if n % 2 == 0)
print(odd_numbers)

odd_numbers = list(x for x in num1 if not evenness(x))

print(odd_numbers)

odd_numbers = list(filter(lambda x: x%2 == 0, num1))

print(odd_numbers)

odd_numbers = list(filter(lambda x: not evenness(x), num1))

print(odd_numbers)
print("----")
#
#
# Лямбда функции в Python – это такие функции, которые не имеют названия.
# Их также называют анонимными.
# Слово «lambda» является служебным, и не отражает сути конкретной функции.
#
# Лямбда-функция — это короткая однострочная функция, которой даже не нужно имя
давать.
# Такие выражения содержат лишь одну инструкцию,
# поэтому, например, if, for и while использовать нельзя.
#
# Создание лямбда функций происходит с помощью ключевого слова lambda следующим
образом:
# lambda <аргумент(ы)>: <выражение>
#
# Лямбда функции могут иметь сколько угодно аргументов или не иметь их вовсе,
# но обязательно должны содержать лишь одно выражение.
#
# В следующем примере создается лямбда функция без аргументов и при вызове
возвращает строку:
#
# lambda: «Просто строка»
# lambda param: «Просто строка, но уже с обязательным аргументом param»
#
# лямбда функции, в отличие от обычных методов, могут содержать только те
выражения,
# которые вы можете уместить в одну строку.
#
def add(a):
return lambda b: a+b
# Присваиваем переменной лямбда функцию ( lambda b: 100+b )
add_to_100 = add(100)
# Через переменную обращаемся к лямбда функции ( lambda b: 100+b )
# Параметр b = 50
print(add_to_100(50)) # 150
#
# Анонимные функции могут содержать лишь одно выражение, но и выполняются они
быстрее.
# Анонимные функции создаются с помощью инструкции lambda.
# Кроме этого, их не обязательно присваивать переменной, как делали мы инструкцией
def func()
def sum(x, y):
return x + y

d = sum( 3, 5 )
print(d) # 8
#
func = lambda x, y: x + y
print( func( 3, 5 ) ) # 8
#
# С помощью type() можно проверить тип:
print( type(func) ) # <class 'function'>
#
# В отличие от функций, здесь не используется ключевое слово return.
# Результат работы и так возвращается.
# lambda функции, в отличие от обычной, не требуется инструкция return,
# а в остальном, ведет себя точно так же:
func = lambda *args: args
print( func(1, 2, 3, 4) ) # (1, 2, 3, 4)
#
# Переменным также можно присваивать встроенные функции.
# Таким образом позже есть возможность вызывать функцию другим именем.
# Такой подход называется непрямым вызовом функции.
# С существующей функцией func синтаксис максимально простой: variable = func
power = lambda x=1, y=2: x**y
square = power # переменнной присвоили функцию

square(5.)
print( square(5.) ) # 25.0
print( square(5) ) # 25
#
power = lambda x,y,pow=2: x**pow + y
A = [power(x,2, 3) for x in [0,1,2]]

print(A) # [2, 3, 10]

#
# Например, нам надо посчитать площадь круга при известном радиусе по следующей
формуле:
# S = pi*(r**2)
# где
# S — это площадь круга
# pi — математическая константа равная 3.14 которую мы получим из стандартной
библиотеки Math
# r — радиус круга — единственная переменная которую мы будем передавать нашей
функции
#
import math #Подключаем библиотеку math

pi_const = round(math.pi, 2) #округляем pi до второго знака

# после запятой иначе она будет выглядеть
# как 3.141592653589793 а нам это будет неудобно
#
# Формула площадь круга по заданному радиусу в обычном варианте записи
def area_of_circle_simple(radius):
return pi_const*(radius**2)

print(area_of_circle_simple(5)) # 78.5
print(area_of_circle_simple(12)) # 452.16
print(area_of_circle_simple(26)) # 2122.64
#
# это всё может выглядеть куда круче, если записывать это через lambda:
#
print((lambda radius: pi_const*(radius**2))(5)) # 78.5
print((lambda radius: pi_const*(radius**2))(12)) # 452.16
print((lambda radius: pi_const*(radius**2))(26)) # 2122.64
#
# анонимный вызов функции подразумевает то, что вы используете её, нигде не
объявляя
# print( (lambda перечисляются аргументы через запятую : что то с ними делается)
(передаем аргументы) )
#
#
# пример с двумя входными аргументами.
# Например, нам надо посчитать объем конуса по следующей формуле:
# V = (height*pi_const*(radius**2))/3
#
import math #Подключаем библиотеку math

pi_const = round(math.pi, 2) #округляем pi до второго знака

# после запятой иначе она будет выглядеть
# как 3.141592653589793 а нам это будет неудобно
#
# Формула объем конуса в обычном варианте записи
def cone_volume(height, radius):
volume = (height*pi_const*(radius**2))/3
return volume

print(cone_volume(3, 10)) # 314.0

#
# это всё может выглядеть куда круче, если записывать это через lambda:

print((lambda height, radius : (height*pi_const*(radius**2))/3)(3, 10)) # 314.0

#
#
# пример с тремя входными аргументами.
# Например, нам надо посчитать объем усеченного конуса по следующей формуле:
# V = (pi_const*height*(r1**2 + r1*r2 + r2**2))/3

import math #Подключаем библиотеку math

pi_const = round(math.pi, 2) #округляем pi до второго знака
# после запятой иначе она будет выглядеть
# как 3.141592653589793 а нам это будет неудобно
#
# Формула объем усеченного конуса в обычном варианте записи
def cone_volume(h,r1,r2):
return (pi_const * h * (r1 ** 2 + r1 * r2 + r2 ** 2))/3

print(cone_volume(12, 8, 5)) # 1620.24

print(cone_volume(15, 10, 6)) # 077.20
print(cone_volume(20, 12, 9)) # 6970.8
#
# это всё может выглядеть куда круче, если записывать это через lambda:
#
print((lambda height, radius1, radius2 : (height*pi_const*(radius1**2 +
radius1*radius2 + radius2**2))/3)(12, 8, 5))
print((lambda height, radius1, radius2 : (height*pi_const*(radius1**2 +
radius1*radius2 + radius2**2))/3)(15, 10, 6))
print((lambda height, radius1, radius2 : (height*pi_const*(radius1**2 +
radius1*radius2 + radius2**2))/3)(20, 12, 9))
#
#
#
# Сортировку можно делать с помощью lambda функции
#
# Сортировать одномерные списки в python с помощью lambda
# довольно глупо — это будет выглядеть, как бряцание мускулами там, где оно совсем
не нужно.
# Ну серьезно допустим, у нас есть обычный список (не важно состоящий из строк или
чисел)
# и нам надо его отсортировать — тут же проще всего использовать встроенную функцию
sorted().
#
new_int_list = [43,23,56,75,12,32] # Создаем список чисел
print(sorted(new_int_list)) # Сортируем список чисел
new_string_list = ['zum6z', 'yybt0', 'h1uwq', '2k9f9', 'hin9h', 'b0p0m'] # Создаем
список строк
print(sorted(new_string_list)) # Сортируем список строк
#
# В таких ситуациях, действительно, хватает обычного sorted()
# (ну или sort(), если вам нужно изменить текущий список на месте без создания
нового, изменив исходный).
# Но что, если нужно отсортировать список словарей по разным ключам?
# Но иногда имеется список кастомных объектов, сортировать которые нужно на основе
значений одного из полей.
# В таком случае можно передать параметр key в sort или sorted.
# Он и будет являться функцией.
# Тут может быть запись как в классическом стиле, так и в функциональном.
#
# Создали список из словарей книг
asoiaf_books = [
{'title' : 'Game of Thrones', 'published' : '1996-08-01', 'pages': 694},
{'title' : 'Clash of Kings', 'published' : '1998-11-16', 'pages': 761},
{'title' : 'Storm of Swords', 'published' : '2000-08-08', 'pages': 973},
{'title' : 'Feast for Crows', 'published' : '2005-10-17', 'pages': 753},
{'title' : 'Dance with Dragons', 'published' : '2011-07-12', 'pages': 1016}
]
#
# dict.get() получить значение по ключу из словаря
#
#
# записать это в обычном варианте записи:
#
# Функция по получению названия книги
def get_title(book):
return book.get('title')
#
# Функция по получению даты публикации книги
def get_publish_date(book):
return book.get('published')
#
# Функция по получению количества страниц в книге
def get_pages(book):
return book.get('pages')
#
# Сортируем по названию
asoiaf_books.sort(key=get_title)
for book in asoiaf_books:
print(book)
print('-------------')
# Сортируем по датам
asoiaf_books.sort(key=get_publish_date)
for book in asoiaf_books:
print(book)
print('-------------')
# Сортируем по количеству страниц
asoiaf_books.sort(key=get_pages)
for book in asoiaf_books:
print(book)
#
#
#
# записать это через lambda:

# Сортируем по названию
for book in sorted(asoiaf_books, key=lambda book: book.get('title')):
print(book)
print('-------------')
#
# Сортируем по датам
for book in sorted(asoiaf_books, key=lambda book: book.get('published')):
print(book)
print('-------------')
#
# Сортируем по количеству страниц
for book in sorted(asoiaf_books, key=lambda book: book.get('pages')):
print(book)
#
# результат в обоих случаях

# {'title': 'Clash of Kings', 'published': '1998-11-16', 'pages': 761}

# {'title': 'Dance with Dragons', 'published': '2011-07-12', 'pages': 1016}
# {'title': 'Feast for Crows', 'published': '2005-10-17', 'pages': 753}
# {'title': 'Game of Thrones', 'published': '1996-08-01', 'pages': 694}
# {'title': 'Storm of Swords', 'published': '2000-08-08', 'pages': 973}
# -------------
# {'title': 'Game of Thrones', 'published': '1996-08-01', 'pages': 694}
# {'title': 'Clash of Kings', 'published': '1998-11-16', 'pages': 761}
# {'title': 'Storm of Swords', 'published': '2000-08-08', 'pages': 973}
# {'title': 'Feast for Crows', 'published': '2005-10-17', 'pages': 753}
# {'title': 'Dance with Dragons', 'published': '2011-07-12', 'pages': 1016}
# -------------
# {'title': 'Game of Thrones', 'published': '1996-08-01', 'pages': 694}
# {'title': 'Feast for Crows', 'published': '2005-10-17', 'pages': 753}
# {'title': 'Clash of Kings', 'published': '1998-11-16', 'pages': 761}
# {'title': 'Storm of Swords', 'published': '2000-08-08', 'pages': 973}
# {'title': 'Dance with Dragons', 'published': '2011-07-12', 'pages': 1016}

# Таким образом, lambda функция хорошо подходит для сортировки многомерных списков
по разным параметрам.
#
#
# Как уже упоминалось, лямбда могут иметь только одно выражение (expression) в
теле.
# Обратите внимание, что речь идет не об инструкции (statement).
# Выражение и инструкции — две разные вещи, в которых часто путаются.
# В программировании инструкцией является строка кода, выполняющая что-то, но не
генерирующая значение.
# Например, инструкция if или циклы for и while являются примерами инструкций.
# Заменить инструкцию на значение попросту невозможно.
# А вот выражения — это значения.
# Запросто можно заменить все выражения в программе на значения, и программа
продолжит работать корректно.
# Например:
# 3 + 5 — выражение со значением 8
# 10 > 5 — выражение со значением True
# True and (5 < 3) — выражение со значением False
#
# Тело лямбда-функции должно являться выражением, поскольку его значение будет
тем, что она вернет.
# Обязательно запомните это для работы с лямбда-функциями в будущем.
#
# Основная причина применения лямбда функций — создание функции, которая
используется в коде единожды.
# Использование таких функций позволяет снизить число строк кода, которые вам
придется написать.
# Также лямбда функции известны как throw-away функции, которые используются
вместе с filter(), map() и т. п.
#
#
#
# ИСПОЛЬЗОВАНИЕ ЛЯМБДА ФУНКЦИЙ В filter(), map(), reduce()
#
# Функция filter() в Python
#
# Функция filter() в Python применяет другую функцию к заданному итерируемому
объекту
# (список, строка, словарь и так далее), проверяя, нужно ли сохранить конкретный
элемент или нет.
# Простыми словами, она отфильтровывает то, что не проходит и возвращает все
остальное.
#
# Объект фильтра — это итерируемый объект.
# Он сохраняет те элементы, для которых функция вернула True.
# Также можно конвертировать его в list, tuple или другие типы последовательностей
с помощью фабричных методов.
#
# Функция filter() принимает два параметра.
# Первый — имя созданной пользователем функции,
# а второй — итерируемый объект (список, строка, множество, кортеж и так далее).
#
# Она вызывает заданную функцию для каждого элемента объекта как в цикле.
# Синтаксис следующий: filter(in_function|None, iterable)
# возвращаемое значение: filter object
#
# Первый параметр — функция, содержащая условия для фильтрации входных значений.
# Она возвращает True или False.
# Если же передать None, то она удалит все элементы кроме тех, которые вернут True
по умолчанию.
#
# Второй параметр — итерируемый объект, то есть последовательность элементов,
# которые проверяются на соответствие условию.
# Каждый вызов функции использует один из объектов последовательности для
тестирования.
#
# Возвращаемое значение — объект filter,
# который представляет собой последовательность элементов, прошедших проверку.
#
#
# Примеры функции filter()
#
# Функция filter предлагает элегантный вариант фильтрации элементов
последовательности.
# Принимает в качестве аргументов функцию и последовательность, которую необходимо
отфильтровать
# Обратите внимание, что функция, передаваемая в filter должна возвращать значение
True / False,
# чтобы элементы корректно отфильтровались.
#
# Фильтр нечетных чисел
#
# список чисел
numbers = [1, 2, 4, 5, 7, 8, 10, 11]
# функция, которая проверяет числа
def filter_odd_num(in_num):
if(in_num % 2) == 0:
return True
else:
return False
# Применение filter() для удаления нечетных чисел
out_filter = filter(filter_odd_num, numbers)

print("Тип объекта out_filter: ", type(out_filter))

print("Отфильтрованный список: ", list(out_filter))
#
# Вот на что стоит обратить внимание в примере:
# Функция filter() возвращает out_filter, а для проверки типа данных использовалась
type();
# Конструктор list() был вызван для конвертации объекта filter в список Python.
#
#
#
# Фильтр повторяющихся значений из двух списков
"""
Программа для поиска совпадений между
 двумя списками, используя функцию filter()
"""
# Список строк с похожими элементами
list1 = ["Python", "CSharp", "Java", "Go"]
list2 = ["Python", "Scala", "JavaScript", "Go", "PHP", "CSharp"]
# функция, которая проверяет строки на вхождение
def filter_duplicate(string_to_check):
if string_to_check in ll:
return False
else:
return True
# Применение filter() для удаления повторяющихся строк
ll = list2
out_filter = list(filter(filter_duplicate, list1))
ll = list1
out_filter += list(filter(filter_duplicate, list2))
#
print("Отфильтрованный список:", out_filter)
# получим: Отфильтрованный список: ['Java', 'Scala', 'JavaScript', 'PHP']
# код вывел разницу двух списков
#
#
# Использование лямбда-выражений с filter()
#
# Лямбда-выражение в Python также работает как встроенная функция.
# Таким образом ее можно указать вместо функции в качестве аргумента при вызове
filter()
# и избавиться от необходимости написания отдельной функции для фильтрации.
#
#
# Отфильтровать стоп-слова из строки
"""
Программа для удаления стоп-слов
из строки используя функцию filter()
"""
# Список стоп-слов
list_of_stop_words = ["в", "и", "по", "за"]
# Строка со стоп-словами
string_to_process = "Сервис по поиску работы и сотрудников HeadHunter опубликовал
подборку высокооплачиваемых вакансий в России за август."
# lambda-функция, фильтрующая стоп-слова
split_str = string_to_process.split()
filtered_str = ' '.join((filter(lambda s: s not in list_of_stop_words, split_str)))
# получим:
# Отфильтрованная строка:a
# Сервис поиску работы сотрудников HeadHunter опубликовал подборку
высокооплачиваемых вакансий России август.
#
# Поскольку нужно убрать целое слово, строка разбивается на слова.
# После этого стоп-слова отфильтровываются, а все остальное объединяется.
#
#
#
# Пересечение двух массивов
#
#
"""
Программа для поиска общих элементов в двух списках
с использованием функции lambda и filter()
"""
# Два массива, имеющие общие элементы
arr1 = ['p','y','t','h','o','n',' ','3','.','0']
arr2 = ['p','y','d','e','v',' ','2','.','0']

# Лямбда с использованием filter() для поиска общих значений

def interSection(arr1, arr2): # find identical elements
out = list(filter(lambda it: it in arr1, arr2))
return out
# функция main
if __name__ == "__main__":
out = interSection(arr1, arr2)
print("Отфильтрованный список:", out)
# получим: Отфильтрованный список: ['p', 'y', ' ', '.', '0']
#
#
# Функция filter без функции

# можно вызывать функцию filter() без передачи ей функции в качестве первого

аргумента.
# Вместо этого нужно указать None.
# В таком случае фильтр уберет те элементы, результат исполнения которых равен
False.
"""
Вызов функции filter() без функции
"""
# Список значений, которые могут быть True или False
bools = ['bool', 0, None, True, False, 1, 1-1, 2%2]
# Передали None вместо функции в filter()
out = filter(None, bools)
# Вывод результата
for iter in out:
print(iter)
# получим:
# bool
# True
# 1
#
#
# List comprehension вместо filter
#
# Как правило, вместо filter можно использовать list comprehension.
# Чаще всего, вариант с list comprehension более понятный,
# а в некоторых случаях даже быстрее.
#
# -----------------------------------------
# Вернуть только те строки, в которых находятся числа:
#
# с помощью filter
list_of_strings = ['one', 'two', 'list', '', 'dict', '100', '1', '50']
a = list(filter(str.isdigit, list_of_strings))
print(a)
#
#
# с помощью list comprehension
list_of_strings = ['one', 'two', 'list', '', 'dict', '100', '1', '50']
a = [s for s in list_of_strings if s.isdigit()]
print(a)
#
# в обох случаях результат:
# ['100', '1', '50']
# -----------------------------------------
# Из списка чисел оставить только нечетные:
#
# с помощью filter
nums = [10, 111, 102, 213, 314, 515]
a = list(filter(lambda x: x % 2 == 1, nums))
print(a)
#
#
# с помощью list comprehension
nums = [10, 111, 102, 213, 314, 515]
a = [n for n in nums if n % 2 == 1]
print(a)
# в обох случаях результат:
# [111, 213, 515]
# -----------------------------------------
# Из списка чисел оставить только четные:
#
# с помощью filter
nums = [10, 111, 102, 213, 314, 515]
a = list(filter(lambda x: x % 2 == 0, nums))
print(a)
#
#
# с помощью list comprehension
nums = [10, 111, 102, 213, 314, 515]
a = [n for n in nums if n % 2 == 0]
print(a)
# в обох случаях результат:
# [10, 102, 314]
# -----------------------------------------
# Из списка слов оставить только те,
# у которых количество букв больше двух:
#
# с помощью filter
list_of_words = ['one', 'two', 'list', '', 'dict']
a = list(filter(lambda x: len(x) > 2, list_of_words))
print(a)
#
#
# с помощью list comprehension
list_of_words = ['one', 'two', 'list', '', 'dict']
a = [word for word in list_of_words if len(word) > 2]
print(a)
# в обох случаях результат:
# ['one', 'two', 'list', 'dict']
# -----------------------------------------
#
#
#
#
#
#
#
#
#
# Функция map() в Python
#
# Встроенная в Python функция map() используется для применения функции
# к каждому элементу итерируемого объекта (например, списка или словаря)
# и возврата нового итератора для получения результатов.
# Функция map() возвращает объект map (итератор),
# который мы можем использовать в других частях нашей программы.
# Также мы можем передать объект map в функцию list()
# или другой тип последовательности для создания итерируемого объекта.
#
#
# Использование функции Lambda
#
# Первый аргумент map() — это функция,
# которую мы используем для применения к каждому элементу.
# Python вызывает функцию один раз для каждого элемента итериируемого объекта,
# который мы передаем в map(), и возвращает измененный элемент в объект map.
# В качестве первого аргумента функции мы можем передать определенную пользователем
функцию
# или использовать функции lambda,особенно если выражение будет менее сложным.
#
# Синтаксис map() с функцией lambda выглядит следующим образом:
# map(lambda item: item[] expression, iterable)
#
# реализовать функцию lambda с выражением,
# которое хотим применить к каждому элементу в нашем списке:
numbers = [10, 15, 21, 33, 42, 55]
# Чтобы применить выражение к каждому из наших чисел,
# мы можем использовать map() и lambda:
mapped_numbers = list(map(lambda x: x * 2 + 3, numbers))
# Здесь мы декларируем элемент в нашем списке как x.
# Затем мы добавим наше выражение.
# Затем мы передадим список чисел как итерируемый объект для map().
# распечатаем список объекта map:
print(mapped_numbers)
# [23, 33, 45, 69, 87, 113]
# Мы использовали list(), чтобы объект map был выведен как список,
# а не в трудной для интерпретации объектной форме, например:
mapped_numbers = map(lambda x: x * 2 + 3, numbers)
# <map object at 0x02CA6130>
# Объект map является итератором наших результатов,
# чтобы мы могли использовать его в цикле for
# или использовать list() для превращения в список.
# Мы делаем это здесь, потому что это хороший способ просмотра результатов.
# В итоге map() наиболее полезна для работы с большими наборами данных,
# чтобы мы могли работать с объектом map, и не использовали для них конструктор,
например, list().
#
#
#
colors = ["Goldenrod", "Purple", "Salmon", "Turquoise", "Cyan"]
normalized_colors = map(lambda s: s.casefold(), colors)
print( list(normalized_colors) ) # ['goldenrod', 'purple', 'salmon', 'turquoise',
'cyan']
""" str.casefold() -> str
Преобразование в сложенный регистр
похоже на преобразование к нижнему регистру,
однако более агрессивно.
Например: буква «ß» в нижнем регистре
в немецком языке соотвествует сочетанию «ss»,
однако, ввиду того,что символ «ß» уже имеет нижний регистр,
метод .lower() ни к чему не приведёт,
в то время как casefold() приведёт символ к «ss». """
print( 'ß'.lower() ) # 'ß'
print( 'ß'.casefold() ) # 'ss'
print( 'groß'.casefold() == 'gross' ) # True
#
#
#
# Реализация определяемой пользователем функции
#
# Аналогично lambda мы можем использовать определенную функцию для применения к
итерируемому объекту.
# Функции lambda более полезны при использовании выражения с одной строкой,
# определяемые пользователем функции лучше подходят для более сложных выражений.
# Если же нам нужно передать в функцию другой элемент данных, применяемый к
итерируемому объекту,
# определяемые пользователем функции будут удобнее для чтения.
#
# Например, в следующем итерируемом объекте каждый элемент является словарем,
# содержащим различные детали о каждом из существ в нашем аквариуме:
aquarium_creatures = [
{"name": "sammy", "species": "shark", "tank number": 11, "type": "fish"},
{"name": "ashley", "species": "crab", "tank number": 25, "type": "shellfish"},
{"name": "jo", "species": "guppy", "tank number": 18, "type": "fish"},
{"name": "jackie", "species": "lobster", "tank number": 21, "type":
"shellfish"},
{"name": "charlie", "species": "clownfish", "tank number": 12, "type": "fish"},
{"name": "olly", "species": "green turtle", "tank number": 34, "type":
"turtle"}
]
# Мы решили, что все существа в аквариуме будут перемещены в один и тот же
резервуар.
# Нам нужно обновить наши записи, чтобы показать, что все наши существа
перемещаются в резервуар 42.
# Чтобы дать map() доступ к каждому словарю
# и каждой паре ключ:значение в словарях,
# мы построим вложенную функцию:
def assign_to_tank(aquarium_creatures, new_tank_number):
def apply(x):
x["tank number"] = new_tank_number
return x
return map(apply, aquarium_creatures)

# Мы определяем функцию assign_to_tank(),

# которая принимает aquarium_creatures и new_tank_number в качестве параметров.
# В assign_to_tank() мы передаем apply() как функцию в map() в последней строке.
# Функция assign_to_tank возвратит iterator, полученный от map().
# apply() принимает в качестве аргумента x,
# что означает элемент в нашем списке — одиночный словарь.
# Далее мы указываем, что x — это ключ "tank number" из aquarium_creatures,
# и что он должен хранить переданное значение new_tank_number.
# Мы возвратим каждый элемент после применения нового номера резервуара.
#
# Мы вызовем assign_to_tank() с нашим списком словарей и новый номер резервуара,
# который нам нужно заменить для каждого существа:
assigned_tanks = assign_to_tank(aquarium_creatures, 42)
# После выполнения функции мы сохраним объект фильтра в переменной assigned_tanks,
# которую мы превратим в список и распечатаем:
print(list(assigned_tanks))
# Вывод программы будет выглядеть следующим образом:
# [
# {'name': 'sammy', 'species': 'shark', 'tank number': 42, 'type': 'fish'},
# {'name': 'ashley', 'species': 'crab', 'tank number': 42, 'type': 'shellfish'},
# {'name': 'jo', 'species': 'guppy', 'tank number': 42, 'type': 'fish'},
# {'name': 'jackie', 'species': 'lobster', 'tank number': 42, 'type':
'shellfish'},
# {'name': 'charlie', 'species': 'clownfish', 'tank number': 42, 'type': 'fish'},
# {'name': 'olly', 'species': 'green turtle', 'tank number': 42, 'type':
'turtle'}
# ]
#
#
# Использование встроенной функции с несколькими итерируемыми объектами
#
# Помимо функций lambda и определяемых нами функций,
# мы можем использовать вместе с map() встроенные функции Python.
# Для применения функции с несколькими итерируемыми объектами
# мы передаем имя другого итерируемого объекта после первого.
# Рассмотрим в качестве примера функцию pow(),
# которая принимает два числа и возводит базовое число в указанную степень.

# Здесь у нас списки целых чисел, которые мы хотим использовать с pow():

base_numbers = [2, 4, 6, 8, 10]
powers = [1, 2, 3, 4, 5]
# Затем мы передадим pow() в качестве функции в map()
# и укажем два списка в качестве итерируемых объектов:
numbers_powers = list(map(pow, base_numbers, powers))
print(numbers_powers)
# [2, 16, 216, 4096, 100000]
# map() применит функцию pow() к тому же элементу в каждом списке для возведения в
степень.
# Поэтому в результатах мы увидим 2**1, 4**2, 6**3, 8**4, 10**5
# Если мы передадим map() итерируемый объект, который будет длиннее другого
итерируемого объекта,
# map() остановит расчеты после достижения конца наиболее короткого объекта.
# base_numbers = [2, 4, 6, 8, 10, 12, 14, 16]
# powers = [1, 2, 3, 4, 5]
# Поэтому в результатах мы увидим 2**1, 4**2, 6**3, 8**4, 10**5
#
#
#
# Вместо использования цикла for функция map() дает возможность
# применить функцию к каждому элементу итерируемого объекта.
# Это повышает производительность,
# поскольку функция применяется только к одному элементу за раз
# без создания копий элементов в другом итерируемом объекте.
# Это особенно полезно при обработке больших наборов данных.
# Также map() может принимать несколько итерируемых объектов в качестве аргументов
функции,
# отправляя в функцию по одному элементу каждого итерируемого объекта за раз.

# В Python функция map принимает два аргумента:

# функцию и аргумент составного типа данных, например, список.
# map применяет к каждому элементу списка переданную функцию.

# -------
# Например, с помощью map можно выполнять преобразования элементов.
# Перевести все строки в верхний регистр:
list_of_words = ['one', 'two', 'list', '', 'dict']
print( map(str.upper, list_of_words) )
# <map object at 0x02C49028>
print( list(map(str.upper, list_of_words)) )
# ['ONE', 'TWO', 'LIST', '', 'DICT']

# Примечание: str.upper("aaa") делает то же самое что "aaa".upper()

# -------

# -------
# Конвертация в числа :
list_of_str = ['1', '2', '5', '10']
print( list(map(int, list_of_str)) )
# [1, 2, 5, 10] числа
# -------

# -------
# Например, вы прочитали из файла список чисел,
# изначально все эти числа имеют строковый тип данных,
# чтобы работать с ними - нужно превратить их в целое число:
old_list = ['1', '2', '3', '4', '5', '6', '7']
new_list = []
for item in old_list:
new_list.append(int(item))
print (new_list)
# [1, 2, 3, 4, 5, 6, 7]

# Тот же эффект получить, применив функцию map:

old_list = ['1', '2', '3', '4', '5', '6', '7']
new_list = list(map(int, old_list))
print (new_list)
# [1, 2, 3, 4, 5, 6, 7]
# -------

# Вместе с map удобно использовать лямбда-выражения:

vlans = [100, 110, 150, 200, 201, 202]

print( list(map(lambda x: 'vlan {}'.format(x), vlans)) )
# ['vlan 100', 'vlan 110', 'vlan 150', 'vlan 200', 'vlan 201', 'vlan 202']

# Если функция, которую использует map(), ожидает два аргумента,

# то передаются два списка:
nums = [1, 2, 3, 4, 5]
nums2 = [100, 200, 300, 400, 500]
print( list(map(lambda x, y: x*y, nums, nums2)) )
# [100, 400, 900, 1600, 2500]

L1 = [1,2,3]
L2 = [4,5,6]
new_list = list(map(lambda x,y: x + y, L1, L2))
print (new_list)
# [5, 7, 9]
# Если же количество элементов в списках совпадать не будет,
# то выполнение закончится на минимальном списке:
L1 = [1,2,3]
L2 = [4,5]
new_list = list(map(lambda x,y: + y, L1, L2))
print (new_list)
# [5,7]

# Как видите такой способ занимает меньше строк,

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

def miles_to_kilometers(num_miles):
""" Converts miles to the kilometers """
return num_miles * 1.6

mile_distances = [1.0, 6.5, 17.4, 2.4, 9]

kilometer_distances = list(map(miles_to_kilometers, mile_distances))
print (kilometer_distances)
# [1.6, 10.4, 27.84, 3.84, 14.4]

# А теперь то же самое, только используя lambda выражение:

mile_distances = [1.0, 6.5, 17.4, 2.4, 9]
kilometer_distances = list(map(lambda x: x * 1.6, mile_distances))
print (kilometer_distances)
# [1.6, 10.4, 27.84, 3.84, 14.4]
#
#
#
# List comprehension вместо map
#
# Как правило, вместо map можно использовать list comprehension.
# Чаще всего, вариант с list comprehension более понятный,
# а в некоторых случаях даже быстрее.
# Но map может быть эффективней в том случае,
# когда надо сгенерировать большое количество элементов,
# так как map - итератор, а list comprehension генерирует список.
#
# -----------------------------------------
# Перевести все строки в верхний регистр:
#
# с помощью map
list_of_words = ['one', 'two', 'list', '', 'dict']
a = list(map(str.upper, list_of_words))
print(a)
#
#
# с помощью list comprehension
list_of_words = ['one', 'two', 'list', '', 'dict']
a = [word.upper() for word in list_of_words]
print(a)
#
# в обох случаях результат:
# ['ONE', 'TWO', 'LIST', '', 'DICT']
# -----------------------------------------
# Конвертация в числа:
#
# с помощью map
list_of_str = ['1', '2', '5', '10']
a = list(map(int, list_of_str))
print(a)
#
#
# с помощью list comprehension
list_of_str = ['1', '2', '5', '10']
a = [int(i) for i in list_of_str]
print(a)
# в обох случаях результат:
# [1, 2, 5, 10]
# -----------------------------------------
# Форматирование строк:
#
# с помощью map
vlans = [100, 110, 150, 200, 201, 202]
a = list(map(lambda x: 'vlan {}'.format(x), vlans))
print(a)
#
#
# с помощью list comprehension
vlans = [100, 110, 150, 200, 201, 202]
a = [f'vlan {x}' for x in vlans]
print(a)
# в обох случаях результат:
# ['vlan 100', 'vlan 110', 'vlan 150', 'vlan 200', 'vlan 201', 'vlan 202']
# -----------------------------------------
# Для получения пар элементов используется zip:
#
# с помощью map
nums = [1, 2, 3, 4, 5]
nums2 = [100, 200, 300, 400, 500]
a = list(map(lambda x, y: x*y, nums, nums2))
print(a)
#
#
# с помощью list comprehension
nums = [1, 2, 3, 4, 5]
nums2 = [100, 200, 300, 400, 500]
a = [x * y for x, y in zip(nums, nums2)]
print(a)
# в обох случаях результат:
# [100, 400, 900, 1600, 2500]
# -----------------------------------------