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

rate = 10
hours = 5
salary = rate * hours + 100
print(salary)  # => 150

В программировании для этого используется понятие выражение. Оно обозначает конструкцию, которая вычисляется и дает результат. В примере выше rate * hours + 100 является выражением, составленным из переменных (rate, hours), числового литерала (100) и арифметических операций. Все вместе оно возвращает результат, который можно сохранить в переменную или использовать дальше.

Что нам дает это знание? Мы понимаем, что выражения можно комбинировать бесконечно, постепенно усложняя логику. Каждое новое выражение становится частью большего:

bonus = 50
# Выражение из множества операций
salary = (rate * hours + bonus) * 12 - 500
print(salary)

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

Выражения как аргументы функций

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

# Здесь аргумент функции print — это число 150
print(150)

# А здесь аргумент — выражение, которое сначала вычисляется
print(10 * 15)  # => 150

# Можно комбинировать еще сложнее
rate = 10
hours = 15
bonus = 50
print(rate * hours + bonus)  # => 200

Функция print() просто получает готовое значение и выводит его на экран. Способ получения этого значения функции безразличен. Именно поэтому вызовы функций отлично сочетаются с любыми выражениями.

Вызов функции внутри функции

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

name = 'python'

# Вызов len(name) возвращает 6
# Этот результат сразу используется как аргумент print()
print(len(name))  # => 6

Здесь len(name) вычисляется первым и возвращает число 6. Затем это значение подставляется в вызов print(). Такая комбинация может быть сколько угодно глубокой. Результат одной функции можно передать в другую, потом в следующую.

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

1. Сначала выполняется функция, которая находится "внутри", в нашем случае len(name).
2. Затем ее результат подставляется на место вызова.
3. После этого выполняется внешняя функция, в данном случае print().

Таким образом, код print(len(name)) можно мысленно разложить так:

print(len('python'))

Шаг 1:  len('python')  →  6
Шаг 2:  print(6)       →  выводит 6

1. len(name) → 6
2. print(6)
3. На экране появляется 6.

Этот принцип работает всегда. Сначала вычисляются вложенные вызовы, потом внешний.

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

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

name = 'python'

# Вызов len(name) возвращает 6
# Мы вычитаем 1, чтобы получить индекс последнего символа
last_index = len(name) - 1
print(last_index)  # => 5

# Можно использовать результат функции в арифметике
text = 'hexlet'
double = len(text) * 2
print(double)  # => 12

Здесь вызовы len(name) и len(text) являются полноценными выражениями. Они возвращают значения, которые можно комбинировать с числами, переменными и другими операциями.

Приложение показывает краткую сводку по тексту: его первый и последний символ. Выведите на экран первый и последний символы строки из переменной text в следующем формате:

First: H
Last: !

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