Синтаксис:

lambda [аргументы] : выражение

Лямбда-функция может иметь ноль или более аргументов перед символом ‘:’. При вызове такой функции выполняется выражение, указанное после ‘:’.

Пример определения лямбда-функции:

get_cube = lambda x : x ** 3

Приведенная выше лямбда-функция начинается с ключевого слова lambda, за которым следует параметр x. Выражение x ** 3 после ‘:’ возвращает вызывающему коду значение куба переданного числа. Сама лямбда-функция lambda x : x ** 3 присваивается переменной get_cube для ее последующего вызова как именованной функции. Имя переменной становится именем функции, чтобы мы могли работать с ней как с обычной функцией.

Пример вызова лямбда-функции:

    >>> get_cube(4)
    64

Приведенное выше определение лямбда-функции аналогично следующей стандартной функции:

    def get_cube(x):
        return x ** 3

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

Пример лямбда-функции, не возвращающей значение:

    >>> welcome = lambda user: print('Welcome, ' + name + '!')
    >>> welcome('Anon')
    Welcome, Anon!

Примечание:

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

Следующая лямбда-функция содержит несколько параметров.

Пример лямбда-функции с тремя параметрами:

    >>> get_prod = lambda a, b, c : a * b * c
    >>> get_prod(3, 5, 7)
    105

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

Пример лямбда-функции с неопределенным числом аргументов (используются только первые 3):

Лямбда-функция без параметров

Ниже приведен пример лямбда-функции без параметров.

    >>> welcome = lambda : print('Welcome!')
    >>> welcome()
    Welcome!

Анонимная функция

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

Пример анонимной лямбда-функции:

    >>> (lambda x: x**3)(10)
    1000

Здесь lambda x: x3 определяет анонимную функцию и вызывает ее один раз, передавая аргументы в скобках (lambda x: x3)(10).

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

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

Пример передачи лямбда-функции в качестве параметра:

def run_task(task):
	    print('Before running the task')
	    task()
	    print('After running the task')

run_task(lambda : print('Task is complete!')) # передача анонимной функции
important_task = lambda : print('Important task is complete!') 
run_task(important_task) # передача лямбда-функции

Вывод:

Before running the task
Task is complete!
After running the task
Before running the task
Important task is complete!
After running the task

Представленная выше функция run_task() определена с параметром task, который вызывается как функция внутри run_task(). run_task(lambda : print(‘Task is complete!’)) вызывает функцию run_task() с анонимной лямбда-функцией в качестве аргумента.

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

Пример передачи лямбда-функции в map():

    >>> prime_cube_list = map(lambda x: x**3, [2, 3, 5, 7, 11]) # передача анонимной функции
    >>> next(prime_cube_list)
    8
    >>> next(prime_cube_list)
    27
    >>> next(prime_cube_list)
    125
    >>> next(prime_cube_list)
    343
    >>> next(prime_cube_list)
    1331

Давайте посмотрим на следующий фрагмент:

# Простая программа на Python для демонстрации
# работы yield
  
# Функция-генератор, которая выдает 2 при
# первом обращении, 4 — при втором и
# 8 — при третьем
def simple_generator():
    yield 2
    yield 4
    yield 8
  
# Код для проверки simple_generator()
for value in simple_generator(): 
    print(value)

Вывод:

2
4
8

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

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

# Программа на Python для генерации степеней 2
# от 2 до 256
def get_next_num():
    n = 2
  
    # Бесконечный цикл для генерации степеней 2
    while True:
        yield n
        n *= 2  # При последующем обращении к 
                # get_next_num() выполнение
                # продолжится отсюда 
  
# Код для проверки get_next_num()
for num in get_next_num():
    if num > 256:
         break    
    print(num)

Вывод:

2
4 
8 
16
32
64
128
256

Кубический корень обозначается символом «3√». В случае с квадратным корнем мы использовали только символ ‘√’ без указания степени, который также называется радикалом.

Например, кубический корень из 125, обозначаемый как 3√125, равен 5, так как при умножении 5 на само себя три раза получается 5 x 5 x 5 = 125 = 5^3.

Кубический корень в Python

Чтобы вычислить кубический корень в Python, используйте простое математическое выражение x ** (1. / 3.), результатом которого является кубический корень из x в виде значения с плавающей точкой. Для проверки, корректно ли произведена операция извлечения корня, округлите полученный результат до ближайшего целого числа и возведите его в третью степень, после сравните, равен ли результат x.

x = 8

cube_root = x ** (1./3.)

print(cube_root)

Вывод

2.0

В Python для того, чтобы возвести число в степень, мы используем оператор **. Указание степени, равной 1/3, в выражении с ** позволяет получить кубический корень данного числа.

Извлечение кубического корня из отрицательного числа в Python

Мы не можем найти кубический корень из отрицательных чисел указанным выше способом. Например, кубический корень из целого числа -64 должен быть равен -4, но Python возвращает 2+3.464101615137754j.

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

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

def get_cube_root(x):
    if x < 0:
        x = abs(x)
        cube_root = x**(1/3)*(-1)
    else:
        cube_root = x**(1/3)
    return cube_root

print(round(get_cube_root(64)))
print(get_cube_root(-64))

Вывод

4
-3.9999999999999996

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

Использование функции Numpy cbrt()

Библиотека numpy предлагает еще один вариант нахождения кубического корня в Python, который заключается в использовании метода cbrt(). Функция np.cbrt() вычисляет кубический корень для каждого элемента переданного ей массива.

import numpy as np 

cubes = [125, -64, 27, -8, 1] 
cube_roots = np.cbrt(cubes) 
print(cube_roots)

Вывод

[ 5. -4.  3. -2.  1.]

Функция np.cbrt() — самый простой способ получения кубического корня числа. Она не испытывает проблем с отрицательными входными данными и возвращает целочисленное число, например, -4 для переданного в качестве аргумента числа -64, в отличие от вышеописанных подходов.

В этой статье мы рассмотрим несколько примеров использования циклов for с функцией range() в Python.

Циклы for в Python

Циклы for повторяют определённый код для некоторого набора значений.

Из документации Python можно узнать, что в нем циклы for работают несколько иначе, чем в таких языках, как JavaScript или C.

Цикл for присваивает итерируемой переменной каждое значение из предоставленного списка, массива или строки и повторяет код в теле цикла for для каждого установленного таким образом значения переменной-итератора.

В приведенном ниже примере мы используем цикл for для вывода каждого числа в нашем массиве.

# Простой пример цикла for
for i in [0, 1, 2, 3, 4, 5]:
    print(i, end="; ") # выведет: 0; 1; 2; 3; 4; 5; 

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

# Пример посложнее
for i in [0, 1, 2, 3, 4, 5]:
    x = (i-2)*(i+2) - i**2 + 4
    print(x, end="; ") # выведет: 0; 0; 0; 0; 0; 0;

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

Функция Range в Python

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

range(stop)
range(start, stop[, step])

Аргумент start — это первое значение в диапазоне. Если функция range() вызывается только с одним аргументом, то Python считает, что start = 0.

Аргумент stop — это верхняя граница диапазона. Важно понимать, что само граничное значение не включается в последовательность.

В примере ниже у нас есть диапазон, начинающийся со значения по умолчанию, равному 0, и включающий целые числа меньше 6.

# Использование range() с единственным аргументом
for i in range(6):
    print(i, end="; ") # выведет: 0; 1; 2; 3; 4; 5; 

В следующем примере мы задаем start = -2 и включаем целые числа меньше 4.

# В этот раз передаются два аргумента
for i in range(-2, 4):
    print(i, end="; ") # выведет: -2; -1; 0; 1; 2; 3; 

Необязательное значение step (шаг) управляет приращением между значениями последовательности. По умолчанию step = 1.

В нашем последнем примере мы используем диапазон целых чисел от -2 до 6 и задаем step = 2.

# Здесь используются все аргументы range()
for i in range(-2, 6, 2):
    print(i, end="; ") # выведет: -2; 0; 2; 4; 

Заключение

В этой статье мы рассмотрели циклы for в Python и функцию range().

Циклы for обеспечивают повторное выполнение блока кода для всех значений в указанном списке, массиве, строке или последовательности, определенной с помощью функции range().

Как было показано, мы можем использовать range(), чтобы упростить написание цикла for. При вызове данной функции вы обязаны указать stop значение, также вами могут быть определены начальное значение и шаг между целыми числами в возвращаемом диапазоне.

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

Замена элемента в списке на Python

Вы можете заменить элемент в списке на Python, используя цикл for, обращение по индексу или list comprehension. Первые два метода изменяют существующий список, а последний создает новый с заданными изменениями.

Давайте кратко опишем каждый метод:

• Обращение по индексу: мы используем порядковый номер элемента списка для изменения его значения. Знак равенства используется для присвоения нового значения выбранному элементу.
• List comprehension или генератор списка создает новый список из существующего. Синтаксис list comprehension позволяет добавлять различные условия для определения значений в новом списке.
• Цикл For выполняет итерацию по элементам списка. Для внесения изменений в данном случае используется обращение по индексу. Мы применяем метод enumerate() для создания двух списков: с индексами и с соответствующими значениями элементов — и итерируем по ним.

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

Замена элемента в списке на Python: обращение по индексу

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

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

Начнем с создания списка, который содержит цены на наши товары:

prices = [29.30, 10.20, 44.00, 5.99, 81.90]

Мы используем обращение по индексу для выбора и изменения первого элемента в нашем списке 29.30. Данное значение имеет нулевой индекс. Это связано с тем, что списки индексируются, начиная с нуля.

prices[0] = 31.30
print(prices)

Наш код выбирает элемент в нулевой позиции и устанавливает его значение равным 31.30, что на $2 больше прежней цены. Далее мы возвращаем список со скорректированной ценой первого товара:

[31.30, 10.20, 44.00, 5.99, 81.90]

Мы также можем изменить наш список, добавив два к текущему значению prices[0]:

prices[0] = prices[0] + 2
print(prices)

prices[0] соответствует первому элементу в нашем списке (тот, который находится в позиции с нулевым индексом).

Этот код выводит список с теми же значениями, что и в первом случае:

[31.30, 10.20, 44.00, 5.99, 81.90]

Замена элемента в списке на Python: list comprehension

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

Использование list comprehension позволяет перебирать элементы существующего списка и образовывать из них новый список на основе определенного критерия. Например, из последовательности слов можно скомпоновать новую, выбрав только те, которые начинаются на «C».

Здесь мы написали программу, которая рассчитывает 30% скидку на все товары в магазине одежды, стоимость которых превышает $40. Мы используем представленный ранее список цен на товары:

prices = [29.30, 10.20, 44.00, 5.99, 81.90]

Далее мы применяем list comprehension для замены элементов в нашем списке:

sale_prices = [round(price - (price * 30 / 100), 2) if price > 40 else price for price in prices]
print(sale_prices)

Таким образом, наш генератор проходит по списку «prices» и ищет значения стоимостью более 40 долларов. К найденным товарам применяется скидка в 30%. Мы округляем полученные значения цен со скидкой до двух десятичных знаков после точки с помощью метода round().

Наш код выводит следующий список с новыми ценами:

[29.3, 10.2, 30.8, 5.99, 57.33]

Замена элемента в списке на Python: цикл for

Вы можете изменить элементы списка с помощью цикла for. Для этого нам понадобится функция Python enumerate(). Эта функция возвращает два списка: список с номерами индексов и список со значениями соответствующих элементов. Мы можем выполнить необходимые итерации по этим двум последовательностям с помощью единственного цикла for.

В этом примере мы будем использовать тот же список цен:

prices = [29.30, 10.20, 44.00, 5.99, 81.90]

Затем мы определим цикл for, который проходит по данному списку с помощью функции enumerate():

for index, item in enumerate(prices):
	if item > 40:
		prices[index] = round(prices[index] - (prices[index] * 30 / 100), 2)

print(prices)

В коде выше переменная «index» содержит позиционный номер элемента. В свою очередь «item» — это значение, хранящееся в элементе списка на данной позиции. Индекс и соответствующее значение, возвращаемые методом enumerate(), разделяются запятой.

Подобное получение двух или более значений из возвращаемого функцией кортежа называется распаковкой. Мы «распаковали» элементы двух списков из метода enumerate().

Здесь мы используем ту же формулу, что и ранее, для расчета 30% скидки на товары стоимостью более 40 долларов. Давайте запустим наш код и посмотрим, что получится:

[29.3, 10.2, 30.8, 5.99, 57.33]

Наш код успешно изменяет товары в списке «prices» в соответствии с нашей скидкой.

Заключение

Вы можете заменить элементы в списке на Python с помощью обращения по индексу, list comprehension или цикла for.

Если вы хотите изменить одно значение в списке, то наиболее подходящим будет обращение по индексу. Для замены нескольких элементов в списке, удовлетворяющих определенному условию, хорошим решением будет использование list comprehension. Хотя циклы for более функциональны, они менее элегантны, чем генераторы списков.

Определение функции

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

Синтаксис:

    def имя_функции(параметры):
        """docstring"""
        инструкция1
        инструкция2
        ...
        ...
        return [выражение]

За ключевым словом def следует подходящий идентификатор (имя функции) и круглые скобки. В круглых скобках может быть дополнительно указан один или несколько параметров. Символ ‘:’ после круглых скобок начинает блок с отступом (тело функции).

Первой инструкцией в теле функции может быть строка, которая называется docstring. Она описывает функциональность функции/класса. Строка docstring не является обязательной.

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

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

В следующем примере определена функция welcome().

Пример созданной пользователем функции:

    def welcome():
        """This function prints 'Welcome!'"""
        print('Welcome!')

Выше мы определили функцию welcome(). Первая инструкция — это docstring, в котором сообщается о том, что делает эта функция. Вторая — это метод print, который выводит указанную строку на консоль. Обратите внимание, что welcome() не содержит оператор return.

Чтобы вызвать определенную ранее функцию, просто используйте выражение, состоящее из ее имени и двух круглых скобок ‘()’, в любом месте кода. Например, приведенная выше функция может быть вызвана так: welcome().

Пример вызова определенной пользователем функции:

welcome()

Вывод:

Welcome!

По умолчанию все функции возвращают None, если отсутствует оператор return.

returned_value = welcome()
print(returned_value)

Вывод:

Welcome!
None

Функция help() выводит docstring, как показано ниже.

    >>> help(welcome)
    Help on function welcome in module __main__:
    
    welcome()
        This function prints 'Welcome!'

Параметры функции

Функции также могут принимать на вход один или несколько параметров (они же аргументы) и использовать их для вычислений, определенных внутри функционального блока. В таком случае параметрам/аргументам даются подходящие формальные имена. Для примера изменим функцию welcome(): теперь она принимает в качестве параметра строку user_name; также изменена инструкция с функцией print() для отображения более персонализированного приветствия.

Пример функции с аргументами:

def welcome(user_name):
    print('Welcome, ' + user_name + '!')

welcome('Anon') # вызов функции с параметром

Вывод:

   Welcome, Anon!

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

Параметры функции могут иметь аннотацию для указания типа аргумента с использованием синтаксиса parameter:type. Например, следующая аннотация указывает тип параметра string.

Пример использования аннотации типов:

def welcome(user_name:str):
    print('Welcome, ' + user_name + '!')

welcome('Anon') # передача строки в функцию
                # пройдет нормально
welcome(42) # а передача числа в функцию
            # вызовет ошибку

Передача нескольких параметров

Функция может иметь множество параметров. Представленная ниже вариация welcome() принимает три аргумента.

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

def welcome(first_name:str, last_name:str):
    print('Welcome, ' + first_name + ' ' + last_name + '!')

welcome('Anton', 'Chekhov') # передача аргументов в функцию

Вывод:

Welcome, Anton Chekhov!

Неизвестное количество аргументов

Функция в Python может иметь неизвестное заранее число параметров. Укажите * перед аргументом, если вы не знаете, какое количество параметров передаст пользователь.

Пример функции с неизвестным числом параметров (используются только первые 3):

def welcome(*name_parts):
    message = 'Welcome, ' + name_parts[0] + " "
    message += name_parts[1] + " " + name_parts[2]
    print(message + "!")

welcome('Anton', 'Pavlovich', 'Chekhov')

Вывод:

Welcome, Anton Pavlovich Chekhov!

Следующая функция работает с любым количеством аргументов.

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

def welcome(*name_parts):
    message = 'Welcome,'
    for part in name_parts:
        message += " " + part
    print(message + "!")

welcome('Anton', 'Pavlovich', 'Chekhov',
    'and', 'Fyodor', 'Mikhailovich', 'Dostoevsky')

Вывод:

Welcome, Anton Pavlovich Chekhov and Fyodor Mikhailovich Dostoevsky!

Аргументы-ключевые слова

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

def welcome(first_name:str, last_name:str):
    print('Welcome, ' + first_name + ' ' + last_name + '!')

welcome(last_name='Chekhov', first_name='Anton') # передача
    # аргументов в функцию в произвольном порядке

Вывод:

Welcome, Anton Chekhov!

Аргументы-ключевые слова **kwarg

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

Пример использования **kwarg:

def welcome(**name_parts):
    print('Welcome, ' + name_parts['first_name'] + ' ' + name_parts['last_name'] + '!')

welcome(last_name='Chekhov', first_name='Anton')
welcome(last_name='Chekhov', first_name='Anton', age='28')
welcome(last_name='Chekhov') # вызовет KeyError 

Вывод:

Welcome, Anton Chekhov!
Welcome, Anton Chekhov!

При использовании параметра ** порядок аргументов не имеет значения. Однако их имена должны быть идентичными. Доступ к аргументам-ключевым словам для получения переданных значений осуществляется с помощью такого выражения: имя_параметра_kwarg[‘имя_переданного_аргумента’].

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

Пример функции, вызывающей KeyError:

    def welcome(**name_parts):
        print('Welcome, ' + name_parts['first_name'] + ' ' + name_parts['last_name'] + '!')
    
    welcome(last_name='Chekhov') # вызывет KeyError: необходимо предоставить аргумент 'first_name'

Вывод:

    Traceback (most recent call last):
        ...
        line 2, in welcome
        print('Welcome, ' + name_parts['first_name'] + ' ' + name_parts['last_name'] + '!')
        KeyError: 'first_name'

Параметры со значением по умолчанию

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

Представленная ниже функция welcome() определена с параметром name, имеющим значение по умолчанию ‘Anon’. Оно будет заменено только в том случае, если вызывающей стороной будет передан какой-либо фактический аргумент.

Пример функции со значением по умолчанию:

def welcome(user:str = 'Anon'):
    print('Welcome, ' + user + '!')

welcome()
welcome('Chekhov')

Вывод:

Welcome, Anon!
Welcome, Chekhov!

Функция с возвращаемым значением

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

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

Пример функции с возвращаемым значением:

def get_product(a, b): 
    return a * b

Ниже показано, как при вызове функции get_product() получить результат ее работы.

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

result = get_product(6, 7) 
print(result)
result = get_product(3, get_product(4, 5))
print(result)

Вывод:

42
60

Enum в Python

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

Модуль enum используется для создания перечислений в Python. Вы можете определить их с помощью ключевого слова class или с помощью функционального API.

Существуют специальные производные перечисления enum.IntEnum, enum.IntFlag и enum.Flag.

Простой пример использования enum в Python

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

    #!/usr/bin/python3
    
    from enum import Enum
     
    class Weapon(Enum):
        SWORD = 1
        BOW = 2
        DAGGER = 3
        CLUB = 4
    
    ranged_weapon = Weapon.BOW
    print(ranged_weapon)
    
    if ranged_weapon == Weapon.BOW:
        print("It's a bow")
    
    print(list(Weapon))

В примере у нас есть перечисление Weapon, которое имеет четыре различных значения: SWORD, BOW, DAGGER и CLUB. Чтобы получить доступ к одному из членов enum, мы должны указать название перечисления, за которым следует точка и имя интересующей нас символической константы.

    class Weapon(Enum):
        SWORD = 1
        BOW = 2
        DAGGER = 3
        CLUB = 4

Перечисление Weapon создается нами с помощью ключевого слова class, то есть происходит наследование от базового класса enum.Enum. После этого мы явно задаем числа, соответствующие значениям перечисления.

    ranged_weapon = Weapon.BOW
    print(ranged_weapon)

Здесь символическая константа присваивается переменной и выводится на консоль.

    if ranged_weapon == Weapon.BOW:
        print("It's a bow")

Данный фрагмент демонстрирует использование Weapon.BOW в выражении if.

print(list(Weapon))

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

Вывод:

    Weapon.BOW
    It's a bow
    [, , , ]

Еще один пример использования enum в Python

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

    #!/usr/bin/python3
    
    from enum import Enum
    
    class Weapon(Enum):
            SWORD = 1
            BOW = 2
            DAGGER = 3
            CLUB = 4
    
    weapon = Weapon.SWORD
    
    print(weapon)
    print(isinstance(weapon, Weapon))
    print(type(weapon))
    print(repr(weapon))
    
    print(Weapon['SWORD'])
    print(Weapon(1))

И снова мы имеем дело с enum Weapon, созданным с помощью класса.

print(weapon)

Здесь мы выводим человекочитаемое строковое представление одного из членов перечисления.

print(isinstance(weapon, Weapon))

С помощью метода isinstance мы проверяем, имеет ли переменная значение типа Weapon.

print(type(weapon))

Функция type выводит тип переменной.

print(repr(weapon))

Функция repr предоставляет дополнительную информацию о перечислении.

    print(Weapon['SWORD'])
    print(Weapon(1))

Доступ к символической константе можно получить как по ее имени, так и по значению (индексу).

Вывод:

    Weapon.SWORD
    True
    
    
    Weapon.SWORD
    Weapon.SWORD

Функциональное создание enum в Python

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

    from enum import Enum
    
    Weapon = Enum('Weapon', 'SWORD BOW DAGGER CLUB', start=1)
    
    weapon = Weapon.DAGGER
    print(weapon)
    
    if weapon == Weapon.DAGGER:
        print("Dagger")

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

Weapon = Enum('Weapon', 'SWORD BOW DAGGER CLUB', start=1)

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

Вывод:

    Weapon.DAGGER
    Dagger

Итерирование enum в Python

Мы можем выполнять итерацию по перечислениям Python.

    from enum import Enum

    Weapon = Enum('Weapon', 'SWORD BOW DAGGER CLUB', start=10)

    for weapon in Weapon:
        print(weapon)

    for weapon in Weapon:
        print(weapon.name, weapon.value)

В этом примере мы создаем перечисление Weapon, где символьные константы задаются в виде списка строк.

    for weapon in Weapon:
        print(weapon)

В коде выше мы выполняем итерации по членам перечисления в цикле for.

    for weapon in Weapon:
        print(weapon.name, weapon.value)

Здесь мы выводим их имена и значения.

Вывод:

Weapon.SWORD
Weapon.BOW
Weapon.DAGGER
Weapon.CLUB
SWORD 10
BOW 11
DAGGER 12
CLUB 13

Автоматическое назначение имен для enum в Python

Значения символьных констант могут быть автоматически установлены с помощью функции auto().

    #!/usr/bin/python3
    
    from enum import Enum, auto
    
    class Weapon(Enum):
        SWORD = auto()
        BOW = auto()
        DAGGER = auto()
        CLUB = auto()
    
    for weapon in Weapon:
        print(weapon.value)

В этом фрагменте мы создали перечисление Weapon, члены которого получают значения с помощью функции auto.

Вывод:

    1
    2
    3
    4

Уникальные значения enum в Python

Значения символьных констант могут быть принудительно уникальными с помощью декоратора @unique.

#!/usr/bin/python3

from enum import Enum, unique

@unique
class Weapon(Enum):
    SWORD = 1
    BOW = 2
    DAGGER = 3
    CLUB = 3
    # CLUB = 4

for weapon in Weapon:
    print(weapon)

Данный пример завершается с ошибкой ValueError: duplicate values found in : CLUB -> DAGGER, потому что члены CLUB и DAGGER имеют одинаковые значения. Если мы закомментируем декоратор @unique, пример выведет три члена; CLUB игнорируется.

Python enum __members__

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

#!/usr/bin/python3

from enum import Enum

Weapon = Enum('Weapon', [('SWORD', 1), ('BOW', 2), 
    ('DAGGER', 3), ('CLUB', 4)])

for name, member in Weapon.__members__.items():
    print(name, member)

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

Вывод:

    SWORD Weapon.SWORD
    BOW Weapon.BOW
    DAGGER Weapon.DAGGER
    CLUB Weapon.CLUB

enum.Flag

Enum.Flag — это базовый класс для создания пронумерованных констант, которые можно объединять с помощью побитовых операций без потери их принадлежности к Flag.

#!/usr/bin/python3

from enum import Flag, auto

class Permission(Flag):
    READ = auto()
    WRITE = auto()
    EXECUTE = auto()

print(list(Permission))
print(Permission.READ | Permission.WRITE)

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

Вывод:

    [<Permission.READ: 1>, <Permission.WRITE: 2>, <Permission.EXECUTE: 4>]
    Permission.WRITE|READ

Код #1: Демонстрация работы yield

# Код на Python3 для демонстрации
# использования ключевого слова yield
 
# генерация нового списка, состоящего
# только из четных чисел
def get_even(list_of_nums) :
    for i in list_of_nums:
        if i % 2 == 0:
            yield i
 
# инициализация списка
list_of_nums = [1, 2, 3, 8, 15, 42]
 
# вывод начального списка
print ("До фильтрации в генераторе: " +  str(list_of_nums))
 
# вывод только четных значений из списка
print ("Только четные числа: ", end = " ")
for i in get_even(list_of_nums):
    print (i, end = " ")

Вывод

До фильтрации в генераторе: [1, 2, 3, 8, 15, 42] 
Только четные числа:  2 8 42

Код #2

# Данная Python программа выводит
# числа от 1 до 15, возведенные в куб,
# используя yield и, следовательно, генератор
 
# Функция ниже будет бесконечно генерировать
# последовательность чисел в третьей степени,
# начиная с 1
def nextCube():
    acc = 1
 
    # Бесконечный цикл
    while True:
        yield acc**3                
        acc += 1 # После повторного обращения
                # исполнение продолжится отсюда
 
# Ниже мы запрашиваем у генератора 
# и выводим ровно 15 чисел
count = 1
for num in nextCube():
    if count > 15:
        break   
    print(num)
    count += 1

Вывод:

1
8
27
64
125
216
343
512
729
1000
1331
1728
2197
2744
3375

Преимущества yield:

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

Недостатки yield:

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

Практическое применение

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

# Код Python3 для демонстрации
# использования ключевого слова yield
 
# Поиск слова pythonru в тексте

# Импорт библиотеки для работы 
# с регулярными выражениями
import re

# Этот генератор создает последовательность
# значений True: по одному на каждое
# найденное слово pythonru
# Также для наглядности он выводит
# обработанные слова
def get_pythonru (text) :
    text = re.split('[., ]+', text)
    for word in text:
        print(word)
        if word == "pythonru":
            yield True
 
# Инициализация строки, содержащей текст для поиска
text = "В Интернете есть множество сайтов, \
            но только один pythonru. \
            Программа никогда не прочтет \
            последнее предложение."

# Инициализация переменной с результатом
result = "не найден"

# Цикл произведет единственную итерацию
# в случае наличия в тексте pythonru и 
# не сделает ни одной, если таких слов нет
for j in get_pythonru(text):
    result = "найден"
    break

print ('Результат поиска: %s' % result)

Вывод

В
Интернете
есть
множество
сайтов
но
только
один
pythonru
Результат поиска: найден

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

Ошибка «SyntaxError: unexpected EOF while parsing» возникает в том случае, когда программа добирается до конца файла, но не весь код еще выполнен. Это может быть вызвано ошибкой в структуре или синтаксисе кода.

EOF значит End of File. Представляет собой последний символ в Python-программе.

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

• Если забыть заключить код в специальную инструкцию, такую как, циклы for или while, или функцию.
• Не закрыть все скобки на строке.

Разберем эти ошибки на примерах построчно.

Пример №1: незавершенные блоки кода

Циклы for и while, инструкции if и функции требуют как минимум одной строки кода в теле. Если их не добавить, результатом будет ошибка EOF.

Рассмотрим такой пример цикла for, который выводит все элементы рецепта:

ingredients = ["325г муки", "200г охлажденного сливочного масла", "125г сахара", "2 ч. л. ванили", "2 яичных желтка"]

for i in ingredients:

Определяем переменную ingredients, которая хранит список ингредиентов для ванильного песочного печенья. Используем цикл for для перебора по каждому из элементов в списке. Запустим код и посмотрим, что произойдет:

File "main.py", line 4
    
                     	^
SyntaxError: unexpected EOF while parsing

Внутри цикла for нет кода, что приводит к ошибке. То же самое произойдет, если не заполнить цикл while, инструкцию if или функцию.

Для решения проблемы требуется добавить хотя бы какой-нибудь код. Это может быть, например, инструкция print() для вывода отдельных ингредиентов в консоль:

for i in ingredients:
	print(i)

Запустим код:

325г муки
200г охлажденного сливочного масла
125г сахара
2 ч. л. ванили
2 яичных желтка

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

Если же кода для такого блока у вас нет, используйте оператор pass как заполнитель. Выглядит это вот так:

for i in ingredients:
	pass

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

Пример №2: незакрытые скобки

Ошибка «SyntaxError: unexpected EOF while parsing» также возникает, если не закрыть скобки в конце строки с кодом.

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

name = "Капитанская дочка"
author = "Александр Пушкин"
genre = "роман"

Отформатируем строку с помощью метода .format():

print('Книга "{}" - это {}, автор {}'.format(name, genre, author)

Значения {} заменяются на реальные из .format(). Это значит, что строка будет выглядеть вот так:

Книга "НАЗВАНИЕ" - это ЖАНР, автор АВТОР

Запустим код:

File "main.py", line 7

              ^
SyntaxError: unexpected EOF while parsing

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

Решаем проблему, добавляя вторую закрывающую скобку («)») в конце строки с print().

print('Книга "{}" - это {}, автор {}'.format(name, genre, author))

Теперь на этой строке закрываются две скобки. И все из них теперь закрыты. Попробуем запустить код снова:

Книга "Капитанская дочка" это роман. Александр Пушкин

Теперь он работает. То же самое произойдет, если забыть закрыть скобки словаря {} или списка [].

Выводы

Ошибка «SyntaxError: unexpected EOF while parsing» возникает, если интерпретатор Python добирается до конца программы до выполнения всех строк.

Для решения этой проблемы сперва нужно убедиться, что все инструкции, включая while, for, if и функции содержат код. Также нужно проверить, закрыты ли все скобки.

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

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

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

Где асинхронность применяется в реальном мире?

Асинхронность больше всего подходит для таких сценариев:

1. Программа выполняется слишком долго.
2. Причина задержки — не вычисления, а ожидания ввода или вывода.
3. Задачи, которые включают несколько одновременных операций ввода и вывода.

Это могут быть:

• Парсеры,
• Сетевые сервисы.

Разница в понятиях параллелизма, concurrency, поточности и асинхронности

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

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

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

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

Составляющие асинхронного программирования

Разберем различные составляющие асинхронного программирования подробно. Также используем код для наглядности.

Сопрограммы

Сопрограммы (coroutine) — это обобщенные формы подпрограмм. Они используются для кооперативных задач и ведут себя как генераторы Python.

Для определения сопрограммы асинхронная функция использует ключевое слово await. При его использовании сопрограмма передает поток управления обратно в цикл событий (также известный как event loop).

Для запуска сопрограммы нужно запланировать его в цикле событий. После этого такие сопрограммы оборачиваются в задачи (Tasks) как объекты Future.

Пример сопрограммы

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

import asyncio


async def async_func():
    print('Запуск ...')
    await asyncio.sleep(1)
    print('... Готово!')


async def main():
    async_func()  # этот код ничего не вернет 
    await async_func()


asyncio.run(main())

Вывод:

Warning (from warnings module):
  File "\AppData\Local\Programs\Python\Python38\main.py", line 8
    async_func() # этот код ничего не вернет
RuntimeWarning: coroutine 'async_func' was never awaited
Запуск ...
... Готово!

Задачи (tasks)

Задачи используются для планирования параллельного выполнения сопрограмм.

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

Пример задачи

В коде ниже создается create_task (встроенная функция библиотеки asyncio), после чего она запускается.

import asyncio


async def async_func():
    print('Запуск ...')
    await asyncio.sleep(1)
    print('... Готово!')


async def main():
    task = asyncio.create_task (async_func())
    await task

asyncio.run(main())

Вывод:

Запуск ...
... Готово!

Циклы событий

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

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

Пример цикла событий

Дальше создаются три задачи, которые добавляются в список. Они выполняются асинхронно с помощью get_event_loop, create_task и await библиотеки asyncio.

import asyncio


async def async_func(task_no):
    print(f'{task_no}: Запуск ...')
    await asyncio.sleep(1)
    print(f'{task_no}: ... Готово!')


async def main():
    taskA = loop.create_task (async_func('taskA'))
    taskB = loop.create_task(async_func('taskB'))
    taskC = loop.create_task(async_func('taskC'))
    await asyncio.wait([taskA,taskB,taskC])


if __name__ == "__main__":
    try:
        loop = asyncio.get_event_loop()
        loop.run_until_complete(main())
    except :
        pass

Вывод:

taskA: Запуск ...
taskB: Запуск ...
taskC: Запуск ...
taskA: ... Готово!
taskB: ... Готово!
taskC: ... Готово!

Future

Future — это специальный низкоуровневый объект, который представляет окончательный результат выполнения асинхронной операции.

Если этот объект подождать (await), то сопрограмма дождется, пока Future не будет выполнен в другом месте.

В следующих разделах посмотрим, на то, как Future используется.

Сравнение многопоточности и асинхронности

Прежде чем переходить к асинхронности попробуем проверить многопоточность на производительность и сравним результаты. Для этого теста будем получать данные по URL с разной частотой: 1, 10, 50, 100 и 500 раз соответственно. После этого сравним производительность обоих подходов.

Реализация

Многопоточность:

import requests
import time
from concurrent.futures import ProcessPoolExecutor


def fetch_url_data(pg_url):
    try:
        resp = requests.get(pg_url)
    except Exception as e:
        print(f"Возникла ошибка при получении данных из url: {pg_url}")
    else:
        return resp.content
        

def get_all_url_data(url_list):
    with ProcessPoolExecutor() as executor:
        resp = executor.map(fetch_url_data, url_list)
    return resp
    

if __name__=='__main__':
    url = "https://www.uefa.com/uefaeuro-2020/"
    for ntimes in [1,10,50,100,500]:
        start_time = time.time()
        responses = get_all_url_data([url] * ntimes)
        print(f'Получено {ntimes} результатов запроса за {time.time() - start_time} секунд')

Вывод:

Получено 1 результатов запроса за 0.9133939743041992 секунд
Получено 10 результатов запроса за 1.7160518169403076 секунд
Получено 50 результатов запроса за 3.842841625213623 секунд
Получено 100 результатов запроса за 7.662721633911133 секунд
Получено 500 результатов запроса за 32.575703620910645 секунд

ProcessPoolExecutor — это пакет Python, который реализовывает интерфейс Executor. fetch_url_data — функция для получения данных по URL с помощью библиотеки request. После получения get_all_url_data используется, чтобы замапить function_url_data на список URL.

Асинхронность:

import asyncio
import time
from aiohttp import ClientSession, ClientResponseError


async def fetch_url_data(session, url):
    try:
        async with session.get(url, timeout=60) as response:
            resp = await response.read()
    except Exception as e:
        print(e)
    else:
        return resp
    return


async def fetch_async(loop, r):
    url = "https://www.uefa.com/uefaeuro-2020/"
    tasks = []
    async with ClientSession() as session:
        for i in range(r):
            task = asyncio.ensure_future(fetch_url_data(session, url))
            tasks.append(task)
        responses = await asyncio.gather(*tasks)
    return responses


if __name__ == '__main__':
    for ntimes in [1, 10, 50, 100, 500]:
        start_time = time.time()
        loop = asyncio.get_event_loop()
        future = asyncio.ensure_future(fetch_async(loop, ntimes))
        # будет выполняться до тех пор, пока не завершится или не возникнет ошибка
        loop.run_until_complete(future)
        responses = future.result()
        print(f'Получено {ntimes} результатов запроса за {time.time() - start_time} секунд')

Вывод:

Получено 1 результатов запроса за 0.41477298736572266 секунд
Получено 10 результатов запроса за 0.46897053718566895 секунд
Получено 50 результатов запроса за 2.3057644367218018 секунд
Получено 100 результатов запроса за 4.6860511302948 секунд
Получено 500 результатов запроса за 18.013994455337524 секунд

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

Функция fetch_async используется для добавления задачи в объект цикла событий, а fetch_url_data — для чтения данных URL с помощью пакета session. Метод future_result возвращает ответ всех задач.

Результаты

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

Выводы

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

Прочитав статью, вы узнаете как:

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

Так как модуль subprocess почти всегда используют с Linux все примеры будут касаться Ubuntu. Для пользователей Windows советую скачать терминал Ubuntu 18.04 LTS.

Функция «run»

Функция run была добавлена в модуль subprocess только в относительно последних версиях Python (3.5). Теперь ее использование является рекомендуемым способом создания процессов и должно решать наиболее распространенные задачи. Прежде всего, давайте посмотрим на простейший случай применения функции run.

Предположим, мы хотим запустить команду ls -al; для этого в оболочке Python нам нужно ввести следующие инструкции:

>>> import subprocess
>>> process = subprocess.run(['ls', '-l', '-a'])

Вывод внешней команды ls отображается на экране:

total 12
drwxr-xr-x 1 cnc  cnc  4096 Apr 27 16:21 .
drwxr-xr-x 1 root root 4096 Apr 27 15:40 ..
-rw------- 1 cnc  cnc  2445 May  6 17:43 .bash_history
-rw-r--r-- 1 cnc  cnc  220  Apr 27 15:40 .bash_logout
-rw-r--r-- 1 cnc  cnc  3771 Apr 27 15:40 .bashrc

Здесь мы просто использовали первый обязательный аргумент функции run, который может быть последовательностью, «описывающей» команду и ее аргументы (как в примере), или строкой, которая должна использоваться при запуске с аргументом shell=True (мы рассмотрим последний случай позже).

Захват вывода команды: stdout и stderr

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

>>> process = subprocess.run(['ls', '-l', '-a'], capture_output=True)

Как мы можем впоследствии получить вывод (stdout и stderr) процесса? Если вы посмотрите на приведенные выше примеры, то увидите, что мы использовали переменную process для ссылки на объект CompletedProcess, возвращаемый функцией run. Этот объект представляет процесс, запущенный функцией, и имеет много полезных свойств. Помимо прочих, stdout и stderr используются для «хранения» соответствующих дескрипторов команды, если, как уже было сказано, для аргумента capture_output установлено значение True. В этом случае, чтобы получить stdout, мы должны использовать:

>>> process = subprocess.run(['ls', '-l', '-a'], capture_output=True)
>>> process.stdout
b'total 12\ndrwxr-xr-x 1 cnc  cnc  4096 Apr 27 16:21 .\ndrwxr-xr-x 1 root root 4096 Apr 27 15:40 ..\n-rw------- 1 cnc  cnc  2445 May  6 17:43 .bash_history\n-rw-r--r-- 1 cnc  cnc  220 Apr 27 15:40 .bash_logout...

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

Управление сбоями процесса

Команда, которую мы запускали в предыдущих примерах, была выполнена без ошибок. Однако при написании программы следует принимать во внимание все случаи. Так, что случится, если порожденный процесс даст сбой? По умолчанию ничего «особенного» не происходит. Давайте посмотрим на примере: мы снова запускаем команду ls, пытаясь вывести список содержимого каталога /root, который не доступен для чтения обычным пользователям:

>>> process = subprocess.run(['ls', '-l', '-a', '/root'])

Мы можем узнать, не завершился ли запущенный процесс ошибкой, проверив его код возврата, который хранится в свойстве returncode объекта CompletedProcess:

>>> process.returncode
2

Видите? В этом случае returncode равен 2, подтверждая, что процесс столкнулся с ошибкой, связанной с недостаточными правами доступа, и не был успешно завершен. Мы могли бы проверять выходные данные процесса таким образом чтобы при возникновении сбоя возникало исключение. Используйте аргумент check функции run: если для него установлено значение True, то в случае, когда внешний процесс завершается ошибкой, возникает исключение CalledProcessError:

>>> process = subprocess.run(['ls', '-l', '-a', '/root'])
ls: cannot open directory '/root': Permission denied

Обработка исключений в Python довольно проста. Поэтому для управления сбоями процесса мы могли бы написать что-то вроде:

>>> try:
...     process = subprocess.run(['ls', '-l', '-a', '/root'], check=True)
... except subprocess.CalledProcessError as e:
...     print(f"Ошибка команды {e.cmd}!")
...
ls: cannot open directory '/root': Permission denied
['ls', '-l', '-a', '/root'] failed!
>>>

Исключение CalledProcessError, как мы уже сказали, возникает, когда код возврата процесса не является 0. У данного объекта есть такие свойства, как returncode, cmd, stdout, stderr; то, что они представляют, довольно очевидно. Например, в приведенном выше примере мы просто использовали свойство cmd, чтобы отобразить последовательность, которая использовалась для запуска команды при возникновении исключения.

Выполнение процесса в оболочке

Процессы, запущенные с помощью функции run, выполняются «напрямую», это означает, что для их запуска не используется оболочка: поэтому для процесса не доступны никакие переменные среды и не выполняются раскрытие и подстановка выражений. Давайте посмотрим на пример, который включает использование переменной $HOME:

>>> process = subprocess.run(['ls', '-al', '$HOME'])
ls: cannot access '$HOME': No such file or directory

Как видите, переменная $HOME не была заменена на соответствующее значение. Такой способ выполнения процессов является рекомендованным, так как позволяет избежать потенциальные угрозы безопасности. Однако, в некоторых случаях, когда нам нужно вызвать оболочку в качестве промежуточного процесса, достаточно установить для параметра shell функции run значение True. В таких случаях желательно указать команду и ее аргументы в виде строки:

>>> process = subprocess.run('ls -al $HOME', shell=True)
total 12
drwxr-xr-x 1 cnc  cnc  4096 Apr 27 16:21 .
drwxr-xr-x 1 root root 4096 Apr 27 15:40 ..
-rw------- 1 cnc  cnc  2445 May  6 17:43 .bash_history
-rw-r--r-- 1 cnc  cnc  220  Apr 27 15:40 .bash_logout
...

Все переменные, существующие в пользовательской среде, могут использоваться при вызове оболочки в качестве промежуточного процесса. Хотя это может показаться удобным, такой подход является источником проблем. Особенно при работе с потенциально опасным вводом, который может привести к внедрению вредоносного shell-кода. Поэтому запуск процесса с shell=True не рекомендуется и должен использоваться только в безопасных случаях.

Ограничение времени работы процесса

Обычно мы не хотим, чтобы некорректно работающие процессы бесконечно исполнялись в нашей системе после их запуска. Если мы используем параметр timeout функции run, то можем указать количество времени в секундах, в течение которого процесс должен завершиться. Если он не будет завершен за это время, процесс будет остановлен сигналом SIGKILL. Который, как мы знаем, не может быть перехвачен. Давайте продемонстрируем это, запустив длительный процесс и предоставив timeout в секундах:

>>> process = subprocess.run(['ping', 'google.com'], timeout=5)
PING google.com (216.58.208.206) 56(84) bytes of data.
64 bytes from par10s21-in-f206.1e100.net (216.58.208.206): icmp_seq=1 ttl=118 time=15.8 ms
64 bytes from par10s21-in-f206.1e100.net (216.58.208.206): icmp_seq=2 ttl=118 time=15.7 ms
64 bytes from par10s21-in-f206.1e100.net (216.58.208.206): icmp_seq=3 ttl=118 time=19.3 ms
64 bytes from par10s21-in-f206.1e100.net (216.58.208.206): icmp_seq=4 ttl=118 time=15.6 ms
64 bytes from par10s21-in-f206.1e100.net (216.58.208.206): icmp_seq=5 ttl=118 time=17.0 ms
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python3.8/subprocess.py", line 495, in run
    stdout, stderr = process.communicate(input, timeout=timeout)
  File "/usr/lib/python3.8/subprocess.py", line 1028, in communicate
    stdout, stderr = self._communicate(input, endtime, timeout)
  File "/usr/lib/python3.8/subprocess.py", line 1894, in _communicate
    self.wait(timeout=self._remaining_time(endtime))
  File "/usr/lib/python3.8/subprocess.py", line 1083, in wait
    return self._wait(timeout=timeout)
  File "/usr/lib/python3.8/subprocess.py", line 1798, in _wait
    raise TimeoutExpired(self.args, timeout)
subprocess.TimeoutExpired: Command '['ping', 'google.com']' timed out after 4.999637200000052 seconds

В приведенном выше примере мы запустили команду ping без указания фиксированного числа пакетов ECHO REQUEST, поэтому она потенциально может работать вечно. Мы также установили время ожидания в 5 секунд с помощью параметра timeout. Как мы видим, ping была запущена, а по истечении 5 секунд возникло исключение TimeoutExpired и процесс был остановлен.

Функции call, check_output и check_call

Как мы уже говорили ранее, функция run является рекомендуемым способом запуска внешнего процесса. Она должна использоваться в большинстве случаев. До того, как она была представлена в Python 3.5, тремя основными функциями API высокого уровня, применяемыми для создания процессов, были call, check_output и check_call; давайте взглянем на них вкратце.

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

Поведение функции check_call практически не отличается от run, когда для параметра check задано значение True: она запускает указанную команду и ожидает ее завершения. Если код возврата не равен 0, возникает исключение CalledProcessError.

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

Работа на более низком уровне с классом Popen

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

Предположим, например, что мы хотим соединить два процесса, воссоздав поведение конвейера (pipe) оболочки. Как мы знаем, когда передаем две команды в оболочку, стандартный вывод той, что находится слева от пайпа «|», используется как стандартный ввод той, которая находится справа. В приведенном ниже примере результат выполнения двух связанных конвейером команд сохраняется в переменной:

$ output="$(dmesg | grep sda)"

Чтобы воссоздать подобное поведение с помощью модуля subprocess без установки параметра shell в значение True, как мы видели ранее, мы должны напрямую использовать класс Popen:

dmesg = subprocess.Popen(['dmesg'], stdout=subprocess.PIPE)
grep = subprocess.Popen(['grep', 'sda'], stdin=dmesg.stdout)
dmesg.stdout.close()
output = grep.comunicate()[0]

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

Первое, что мы сделали в приведенном выше фрагменте кода, — это создали объект Popen, представляющий процесс dmesg. Мы установили stdout этого процесса на subprocess.PIPE. Данное значение указывает, что пайп к указанному потоку должен быть открыт.

Затем мы создали еще один экземпляр класса Popen для процесса grep. В конструкторе Popen мы, конечно, указали команду и ее аргументы, но вот что важно, мы установили стандартный вывод процесса dmesg в качестве стандартного ввода для grep (stdin=dmesg.stdout), чтобы воссоздать поведение конвейера оболочки.

После создания объекта Popen для команды grep мы закрыли поток stdout процесса dmesg, используя метод close(). Это, как указано в документации, необходимо для того, чтобы первый процесс мог получить сигнал SIGPIPE. Дело в том, что обычно, когда два процесса соединены конвейером, если один справа от «|» (grep в нашем примере) завершается раньше, чем тот, что слева (dmesg), то последний получает сигнал SIGPIPE (пайп закрыт) и по умолчанию тоже заканчивает свою работу.

Однако при репликации пайплайна между двумя командами в Python возникает проблема. stdout первого процесса открывается как в родительском скрипте, так и в стандартном вводе другого процесса. Таким образом, даже если процесс grep завершится, пайп останется открытым в вызывающем процессе (нашем скрипте), поэтому dmesg никогда не получит сигнал SIGPIPE. Вот почему нам нужно закрыть поток stdout первого процесса в нашем основном скрипте после запуска второго.

Последнее, что мы сделали, — это вызвали метод communicate() объекта grep. Этот метод можно использовать для необязательной передачи данных в stdin процесса. Он ожидает завершения процесса и возвращает кортеж. Где первый элемент — это stdout (на который ссылается переменная output), а второй — stderr процесса.

Заключение

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

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

В этом руководстве поговорим об ошибке «NameError name is not defined». Разберем несколько примеров и разберемся, как эту ошибку решать.

Что такое NameError?

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

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

Самая распространенная NameError выглядит вот так:

NameError: name 'some_name' is not defined

Разберем частые причина возникновения этой ошибки.

Причина №1: ошибка в написании имени переменной или функции

Для человека достаточно просто сделать опечатку. Также просто для него — найти ее. Но это не настолько просто для Python.

Язык способен интерпретировать только те имена, которые были введены корректно. Именно поэтому важно следить за правильностью ввода всех имен в коде.

Если ошибку не исправить, то возникнет исключение. Возьмем в качестве примера следующий код:

books = ["Near Dark", "The Order", "Where the Crawdads Sing"]
print(boooks)

Он вернет:

Traceback (most recent call last):
  File "main.py", line 3, in <module>
	print(boooks)
NameError: name 'boooks' is not defined

Для решения проблемы опечатку нужно исправить. Если ввести print(books), то код вернет список книг.

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

Причина №2: вызов функции до объявления

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

Напишем программу, которая вызывает функцию до объявления:

books = ["Near Dark", "The Order", "Where the Crawdads Sing"]

print_books(books)

def print_books(books):
	for b in books:
		print(b)

Код вернет:

Traceback (most recent call last):
  File "main.py", line 3, in <module>
	print_books(books)
NameError: name 'print_books' is not defined

На 3 строке мы пытаемся вызвать print_books(). Однако эта функция объявляется позже.

Чтобы исправить эту ошибку, нужно перенести функцию выше:

def print_books(books):
	for b in books:
		print(b)

books = ["Near Dark", "The Order", "Where the Crawdads Sing"]

print_books(books)

Причина №3: переменная не объявлена

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

Посмотрим на программу, которая выводит список книг:

for b in books:
    print(b)

Такой код вернет:

Traceback (most recent call last):
  File "main.py", line 1, in <module>
	for b in books:
NameError: name 'books' is not defined

Переменная books объявлена не была.

Для решения проблемы переменную нужно объявить в коде:

books = ["Near Dark", "The Order", "Where the Crawdads Sing"]

for b in books:
    print(b)

Причина №4: попытка вывести одно слово

Чтобы вывести одно слово, нужно заключить его в двойные скобки. Таким образом мы сообщаем Python, что это строка. Если этого не сделать, язык будет считать, что это часть программы. Рассмотрим такую инструкцию print():

print(Books)

Этот код пытается вывести слово «Books» в консоль. Вместо этого он вернет ошибку:

Traceback (most recent call last):
  File "main.py", line 1, in <module>
	print(Books)
NameError: name 'Books' is not defined

Python воспринимает «Books» как имя переменной. Для решения проблемы нужно заключить имя в скобки:

print("Books")

Теперь Python знает, что нужно вывести в консоли строку, и код возвращает Books.

Причина №5: объявление переменной вне области видимости

Есть две области видимости переменных: локальная и глобальная. Локальные переменные доступны внутри функций или классов, где они были объявлены. Глобальные переменные доступны во всей программе.

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

Следующий код пытается вывести список книг вместе с их общим количеством:

def print_books():
  books = ["Near Dark", "The Order", "Where the Crawdads Sing"]
  for b in books:
      print(b)

print(len(books))

Код возвращает:

Traceback (most recent call last):
  File "main.py", line 5, in <module>
	print(len(books))
NameError: name 'books' is not defined

Переменная books была объявлена, но она была объявлена внутри функции print_books(). Это значит, что получить к ней доступ нельзя в остальной части программы.

Для решения этой проблемы нужно объявить переменную в глобальной области видимости:

books = ["Near Dark", "The Order", "Where the Crawdads Sing"]

def print_books():
  for b in books:
      print(b)


print(len(books))

Код выводит название каждой книги из списка books. После этого выводится общее количество книг в списке с помощью метода len().

List comprehension — это упрощенный подход к созданию списка, который задействует цикл for, а также инструкции if-else для определения того, что в итоге окажется в финальном списке.

Преимущества list comprehension

У list comprehension есть три основных преимущества.

1. Простота. List comprehension позволяют избавиться от циклов for, а также делают код более понятным. В JavaScript, например, есть нечто похожее в виде map() и filter(), но новичками они воспринимаются сложнее.
2. Скорость. List comprehension быстрее for-циклов, которые он и заменяет. Это один из первых пунктов при рефакторинге Python-кода.
3. Принципы функционального программирования. Это не так важно для начинающих, но функциональное программирование — это подход, при котором изменяемые данные не меняются. Поскольку list comprehensions создают новый список, не меняя существующий, их можно отнести к функциональному программированию.

Создание первого list comprehension

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

Для начала возьмем простейший пример: создадим список из цифр от 1 до 5, используя функцию range().

>>> nums = [n for n in range(1,6)]
>>> print(nums)
[1, 2, 3, 4, 5]

В этом примере каждое значение диапазона присваивается переменной n. Каждое значение возвращается неизменным и добавляется в новый список. Это — та самая n перед циклом for.

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

List comprehension с изменением

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

>>> nums = [1, 2, 3, 4, 5]
>>> squares = [n*n for n in nums]
>>> print(squares) 
[1, 4, 9, 16, 25]

В этом примере два изменения по сравнению с прошлым кодом. Во-первых, в качестве источника используется уже существующий список. Во-вторых, list comprehension создает список, где каждое значение — это возведенное в квадрат значения оригинального списка.

List comprehension с if

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

>>> nums = [1, 2, 3, 4, 5]
>>> odd_squares = [n*n for n in nums if n%2 == 1]
>>> print(odd_squares)
[1, 9, 25]

Инструкция if идет после цикла — в данном случае порядок играет роль.

List comprehension с вложенным циклом for

В последнем примере рассмотрим пример со вложенным циклом for.

>>> matrix = [[x for x in range(1, 4)] for y in range(1, 4)]
>>> print(matrix)
[[1, 2, 3], [1, 2, 3], [1, 2, 3]]

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

matrix = [
    [x for x in range(1, 4)]
    for y in range(1, 4)
]
print(matrix)

Последний пример. Создадим список дней рождения из списка словарей. Для этого используем знакомые тактики.

people = [{
  "first_name": "Василий",
  "last_name": "Марков",
  "birthday": "9/25/1984"
}, {
  "first_name": "Регина",
  "last_name": "Павленко",
  "birthday": "8/21/1995"
}]

birthdays = [
  person[term]
  for person in people
  for term in person
  if term == "birthday"
]

print(birthdays)

В этом примере мы сперва перебираем people, присваивая каждый словарь person. После этого перебираем каждый идентификатор в словаре, присваивая ключи term. Если значение term равно birthday, то значение person[term] добавляет в list comprehension.

['9/25/1984', '8/21/1995']

Теперь можете попробовать поработать с list comprehension на собственных примерах. Это сделает код более быстрым и компактным.

Основные особенности функций в Python:

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

Правила создания функций:

1. Для объявления функции в Python используется ключевое слово def.
2. Название функции должно начинаться с символа латинского алфавита в любом регистре или нижнего подчеркивания.
3. В каждой функции есть двоеточие и отступ, после которого записывается сам код программы.
4. Зарезервированные ключевые слова не могут использоваться в качестве названия функции.
5. Функция может содержать несколько параметров или не иметь их совсем.

Создание функции в Python

Для создания нужно написать ключевое слово def. Синтаксис следующий:

def function_name():
    # логика функции
    return result # возврат значения

Создадим и вызовем реальную функцию в Python:

def my_fun():
    print("Как вызвать функцию в Python?")


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

Вывод: Как вызвать функцию в Python?.

Вызов функции в Python

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

def my_fun():
    x = 22 ** 5
    return x

# 1. Вызов функции
my_fun()
# 2. Вызов функции и присвоение результат переменной
a = my_fun()
# 3. Вызов функции и вывод результат в консоль
print(my_fun())

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

def my_fun():  
    print("Hello World")  
    print("Функция вызвана")  
  
my_fun()

Вывод:

Hello World
Функция вызвана

В этом примере вызов функции my_fun() привел к выводу двух строк.

Вызов вложенных функций в Python

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

def out_fun():
    print("Привет, это внешняя функция")  
      
    def in_fun():
        print("Привет, это внутренняя функция")  
    in_fun() 
  
out_fun()

Вывод:

Привет, это внешняя функция
Привет, это внутренняя функция

Здесь функция in_fun() определена внутри out_fun(). Для вызова in_fun() нужно сперва вызвать out_fun(). После этого out_fun() начнет выполняться, что приведет к вызову in_fun().

Внутренняя функция не будет выполняться, если не вызвать внешнюю.

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

def fun1():
    a = 6
    
    def fun2(b):
        a = 4
        print ("Сумма внутренней функции", a + b)
    
    print("Значение внешней переменной a", a)
    fun2(4)

fun1()

Вывод:

Значение внешней переменной a 6
Сумма внутренней функции 8

Функции как объекты первого класса

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

Особенности функций как объектов первого класса:

1. Функции можно присваивать переменным.
2. Функция может быть примером объекта.
3. Функцию можно вернуть из функции.
4. У функций те же свойства и методы, что и у объектов.
5. Функцию можно передать в качестве аргумента при вызове другой функции.

Разберем на примере:

def my_object(text):
    return text.upper()  
  

print(my_object("Вызов my_object"))  
  
upper = my_object  
print(upper("Вызов upper"))  

Вывод:

ВЫЗОВ MY_OBJECT
ВЫЗОВ UPPER

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

class Student:  
    no = 101  
    name = "Владимир"
    
    def show(self):  
        print("№ {}\nИмя {}".format(self.no, self.name))  
  
stud = Student()
stud.show()

Вывод:

№ 101
Имя Владимир

В Python есть несколько методов для удаления элементов из списка: remove(), pop() и clear(). Помимо них также существует ключевое слово del.

Рассмотрим их все.

Пример списка:

my_list = ['Python', 50, 11.50, 'Alex', 50, ['A', 'B', 'C']]

Индекс начинается с 0. В списке my_list на 0-ой позиции находится строка «Python». Далее:

1. Целое число 50
2. Число с плавающей точкой 11.50
3. Снова строка — «Alex»
4. Еще одно число 50
5. Список из строк «A», «B» и «C»

Метод remove()

Метод remove() — это встроенный метод, который удаляет первый совпадающий элемент из списка.

Синтаксис: list.remove(element).

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

Метод не возвращает значений.

Как использовать:

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

Пример: использование метод remove() для удаления элемента из списка

В этом списке есть строки и целые числа. Есть повторяющиеся элементы: строка «Mars» и число 12.

my_list = [12, 'USA', 'Sun', 14, 'Mars', 12, 'Mars']
my_list.remove(12)  # удаляем элемент 12 в начале
print(my_list)
my_list.remove('Mars')  # удаляем первый Mars из списка
print(my_list)
my_list.remove(100)  # ошибка
print(my_list)

Вывод:

['USA', 'Sun', 14, 'Mars', 12, 'Mars']
['USA', 'Sun', 14, 12, 'Mars']
Traceback (most recent call last):
  File "wb.py", line 6, in <module>
    my_list.remove(100)  # ошибка
ValueError: list.remove(x): x not in list

Метод pop()

Этот метод удаляет элемент на основе переданного индекса.

Синтаксис: list.pop(index).

Принимает лишь один аргумент — индекс.

• Для удаления элемента списка нужно передать его индекс. Индексы в списках стартуют с 0. Для получения первого передайте 0. Для удаления последнего передайте -1.
• Этот аргумент не является обязательным. Значение по умолчанию равно -1, поэтому по умолчанию будет удален последний элемент.
• Если этот индекс не найден или он вне диапазона, то метод выбросит исключение IndexError: pop index.

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

Пример: использования метода pop() для удаления элемента

Попробуем удалить элемент с помощью pop:

• По индексу
• Не передавая индекс
• Передав индекс вне диапазона

Удалим из списка «Sun». Индекс начинается с 0, поэтому индекс для «Sun» будет 2.

my_list = [12, 'USA', 'Sun', 14, 'Mars', 12, 'Mars']

# Передавая индекс как 2, чтобы удалить Sun
name = my_list.pop(2)
print(name)
print(my_list)

# метод pop() без индекса - возвращает последний элемент
item = my_list.pop()
print(item)
print(my_list)

# передача индекса за пределами списка
item = my_list.pop(15)
print(item)
print(my_list)

Вывод:

Sun
[12, 'USA', 14, 'Mars', 12, 'Mars']
Mars
[12, 'USA', 14, 'Mars', 12]
Traceback (most recent call last):
  File "wb.py", line 14, in <module>
    item = my_list.pop(15)
IndexError: pop index out of range

Метод clear()

Метод clear() удаляет все элементы из списка.

Синтаксис: list.clear().

Нет ни параметров, ни возвращаемого значения.

Пример

Метод clear() очистит данный список. Посмотрим:

my_list = [12, 'USA', 'Sun', 14, 'Mars', 12, 'Mars']

element = my_list.clear()
print(element)
print(my_list)

Вывод:

None
[]

Ключевое слово del

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

Синтаксис: del list[index].

Также можно выбрать элементы в определенном диапазоне и удалить их с помощью del. Для этого нужно передать начальное и конечное значение диапазона.

Синтаксис: del list[start:stop].

Вот пример того как с помощью del можно удалить первый, последний и сразу несколько элементов списка:

my_list = list(range(7))
print("Исходный список", my_list)

# Чтобы удалить первый элемент
del my_list[0]
print("После удаления первого элемента", my_list)

# Чтобы удалить элемент по индексу
del my_list[5]
print("После удаления элемента", my_list)

# Чтобы удалить несколько элементов
del my_list[1:5]
print("После удаления нескольких элементов", my_list)

Вывод:

Исходный список [0, 1, 2, 3, 4, 5, 6]
После удаления первого элемента [1, 2, 3, 4, 5, 6]
После удаления элемента [1, 2, 3, 4, 5]
После удаления нескольких элементов [1]

Как удалить первый элемент списка

Для этого можно использовать методы remove(), pop(). В случае с remove потребуется передать индекс первого элемента, то есть 0. Также можно использовать ключевое слово del.

Пример показывает применение всех этих способов.

my_list = ['A', 'B', 'C', 'D', 'E', 'F']
print("Список", my_list)

my_list.remove('A')
print("С использованием remove()", my_list)

my_list = ['A', 'B', 'C', 'D', 'E', 'F']
my_list.pop(0)
print("С использованием pop()", my_list)

my_list = ['A', 'B', 'C', 'D', 'E', 'F']
del my_list[0]
print("С использованием del", my_list)

Вывод:

Список ['A', 'B', 'C', 'D', 'E', 'F']
С использованием remove() ['B', 'C', 'D', 'E', 'F']
С использованием pop() ['B', 'C', 'D', 'E', 'F']
С использованием del ['B', 'C', 'D', 'E', 'F']

Как удалить несколько элементов из списка

Методы remove() и pop() могут удалить только один элемент. Для удаления нескольких используется метод del.

Например, из списка ['A', 'B', 'C', 'D', 'E', 'F'] нужно удалить элементы B, C и D. Вот как это делается с помощью del.

my_list2 = ['A', 'B', 'C', 'D', 'E', 'F']
print("Список", my_list2)
del my_list2[1:4]
print("С использованием del", my_list2)

Вывод:

Список ['A', 'B', 'C', 'D', 'E', 'F']
С использованием del ['A', 'E', 'F']

Как удалить элемент из списка с помощью индекса в Python

Для удаления элемента по индексу используйте pop(). Для этого также подойдет ключевое слово del.

# Использование del для удаления нескольких элементов из списка
my_list1 = ['A', 'B', 'C', 'D', 'E', 'F']
print("Список", my_list1)
element = my_list1.pop(2)
print("Используя pop", my_list1)


# Использование del для удаления нескольких элементов из списка
my_list2 = ['A', 'B', 'C', 'D', 'E', 'F']
del my_list2[2]
print("Используя del", my_list2)

Вывод:

Список ['A', 'B', 'C', 'D', 'E', 'F']
Используя pop ['A', 'B', 'D', 'E', 'F']
Используя del ['A', 'B', 'D', 'E', 'F']

Выводы

В Python есть много способов удаления данных из списка. Это методы remove(), pop(), clear() и ключевое слово del.

• remove() — удаляет первый встреченный элемент в списке, который соответствует условию.
• pop() — удаляет элемент по индексу.
• clear() — удаляет все элементы списка.

Пример abs() с целым числом

Следующий код демонстрирует, как получить абсолютное значение 42 положительного числа 42.

x = 42
abs_x = abs(x)
print(f"Абсолютное значение {x} это {abs_x}")
# Вывод: Абсолютное значение 42 это 42

Вывод: «Абсолютное значение 42 это 42».

То же самое, но уже с отрицательным -42.

x = -42
abs_x = abs(x)
print(f"Абсолютное значение {x} это {abs_x}")
#  Вывод: Абсолютное значение -42 это 42

Пример с числом float

Вот как получить абсолютное значение 42.42 и для -42.42:

x = 42.42
abs_x = abs(x)
print(f"Абсолютное значение {x} это {abs_x}")
#  Абсолютное значение 42.42 это 42.42

x = -42.42
abs_x = abs(x)
print(f"Абсолютное значение {x} это {abs_x}")
#  Абсолютное значение -42.42 это 42.42

Комплексное число

Абсолютное значение комплексного числа (3+10j).

complex_number = (3+10j)
abs_complex_number = abs(complex_number)
print(f"Абсолютное значение {complex_number} это {abs_complex_number}")
#  Абсолютное значение (3+10j) это 10.44030650891055

abs() vs fabs()

abs(x) вычисляет абсолютное значение аргумента x. По аналогии функция fabs(x) модуля math вычисляет то же значение. Разница лишь в том, что math.fabs(x) возвращает число с плавающей точкой, а abs(x) вернет целое число, если в качестве аргумента было целое число. Fabs расшифровывается как float absolute value.

Пример c fabs():

x = 42
print(abs(x))
# 42

import math
print(math.fabs(x))
# 42.0

abs() vs. np.abs()

И abs() в Python, и np.abs() в NumPy вычисляют абсолютное значение числа, но есть два отличия. np.abs(x) всегда возвращает число с плавающей точкой. Также np.abs(x) принимает массив NumPy, вычисляя значение для каждого элемента коллекции.

Пример:

x = 42
print(abs(x))
# 42

import numpy as np
print(np.fabs(x))
# 42.0

a = np.array([-1, 2, -4])
print(np.abs(a))
# [1 2 4]

abs и np.abs абсолютно идентичны. Нет разницы какой использовать. У первой преимущество лишь в том, что ее вызов короче.

Вывод

Функция abs() — это встроенная функция, возвращающая абсолютное значение числа. Она принимает целые, с плавающей точкой и комплексные числа на вход.

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

>>> abs(20)
20
>>> abs(20.0)
20.0
>>> abs(-20.0)
20.0

Комплексные числа состоят из двух частей и могут быть записаны в форме a + bj, где a и b — это или целые числа, или числа с плавающей точкой. Абсолютное значение a + bj вычисляется математически как math.sqrt(a**2 + b**2).

>>> abs(3 + 4j)
5.0
>>> math.sqrt(3**2 + 4**2)
5.0

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

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

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

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

Предположим, мы хотим получить квадрат 5. Если мы умножим число (в данном случае 5) на 5, мы получим квадрат этого числа. Для обозначения квадрата числа используется следующая запись:
5² = 25

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

1. Используя оператор возведения в степень

num = 25
sqrt = num ** (0.5)
print("Квадратный корень из числа "+str(num)+" это "+str(sqrt))

Вывод:

Квадратный корень из числа 25 это 5.0

Объяснение: Мы можем использовать оператор «**» в Python, чтобы получить квадратный корень. Любое число, возведенное в степень 0.5, дает нам квадратный корень из этого числа.

2. Использование math.sqrt()

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

a. Использование положительного числа в качестве аргумента.

import math
num = 25
sqrt = math.sqrt(num)
print("Квадратный корень из числа " + str(num) + " это " + str(sqrt))

Вывод: Квадратный корень из числа 25 это 5.0.

b. Использование ноля в качестве аргумента.

import math
num = 0
sqrt = math.sqrt(num)
print("Квадратный корень из числа " + str(num) + " это " + str(sqrt))

Вывод: Квадратный корень из числа 0 это 0.0.

c. Использование отрицательного числа в качестве аргумента.

import math
num = -25
sqrt = math.sqrt(num)
print("Квадратный корень из числа " + str(num) + " это " + str(sqrt))

Вывод:

Traceback (most recent call last):
  File "C:\wb.py", line 3, in <module>
    sqrt = math.sqrt(num)
ValueError: math domain error

Объяснение: Когда мы передаем отрицательное число в качестве аргумента, мы получаем следующую ошибку «math domain error». Из чего следует, что аргумент должен быть больше 0. Итак, чтобы решить эту проблему, мы должны использовать функцию sqrt() из модуля cmath.

3. Использование cmath.sqrt()

Ниже приведены примеры применения cmath.sqrt().

а. Использование отрицательного числа в качестве аргумента.

import cmath
num = -25
sqrt = cmath.sqrt(num)
print("Квадратный корень из числа " + str(num) + " это " + str(sqrt))

Вывод: Квадратный корень из числа -25 это 5j.

Объяснение: Для отрицательных чисел мы должны использовать функцию sqrt() модуля cmath, которая занимается математическими вычислениями над комплексными числами.

b. Использование комплексного числа в качестве аргумента.

import cmath
num = 4 + 9j
sqrt = cmath.sqrt(num)
print("Квадратный корень из числа " + str(num) + " это " + str(sqrt))

Вывод: Квадратный корень из числа (4+9j) это (2.6314309606938298+1.7100961671491028j).

Объяснение: Для нахождения квадратного корня из комплексного числа мы также можем использовать функцию cmath.sqrt().

4. Использование np.sqrt()

import numpy as np
num = -25
sqrt = np.sqrt(num)
print("Квадратный корень из числа " + str(num) + " это " + str(sqrt))

Вывод:

...
RuntimeWarning: invalid value encountered in sqrt
Квадратный корень из числа -25 это nan

5. Использование scipy.sqrt()

import scipy as sc
num = 25
sqrt = sc.sqrt(num)
print("Квадратный корень из числа " + str(num) + " это " + str(sqrt))

Вывод: Квадратный корень из числа 25 это 5.0.

Объяснение: Как и функция sqrt() модуля numpy, в scipy квадратный корень из положительных, нулевых и комплексных чисел может быть успешно вычислен, но для отрицательных возвращается nan с RunTimeWarning.

6. Использование sympy.sqrt()

import sympy as smp
num = 25
sqrt = smp.sqrt(num)
print("Квадратный корень из числа "+str(num)+" это "+str(sqrt))

Вывод: Квадратный корень из числа 25 это 5.

Объяснение: sympy — это модуль Python для символьных вычислений. С помощью функции sympy.sqrt() мы можем получить квадратный корень из положительных, нулевых, отрицательных и комплексных чисел. Единственная разница между этим и другими методами заключается в том, что, если при использовании sympy.sqrt() аргумент является целым числом, то результат также является целым числом, в отличие от других способов, в которых возвращаемое значение всегда число с плавающей точкой, независимо от типа данных аргумента.

Заключение

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

Метод принимает итерируемый объект в качестве аргумента, а поскольку список отвечает этим условиям, то его вполне можно использовать. Также список должен состоять из строк. Если попробовать использовать функцию для списка с другим содержимым, то результатом будет такое сообщение: TypeError: sequence item 0: expected str instance, int found.

Посмотрим на короткий пример объединения списка для создания строки.

vowels = ["a", "e", "i", "o", "u"]
vowels_str = ",".join(vowels)
print("Строка гласных:", vowels_str)

Этот скрипт выдаст такой результат:

Строка гласных: a,e,i,o,u

Почему join() — метод строки, а не списка?

Многие часто спрашивают, почему функция join() относится к строке, а не к списку. Разве такой синтаксис не было бы проще запомнить?

vowels_str = vowels.join(",")

Это популярный вопрос на StackOverflow, и вот простой ответ на него:

Функция join() может использоваться с любым итерируемым объектом, но результатом всегда будет строка, поэтому и есть смысл иметь ее в качестве API строки.

Объединение списка с несколькими типами данных

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

names = ['Java', 'Python', 1]
delimiter = ','
single_str = delimiter.join(names)

Вывод:

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    single_str = delimiter.join(names)
TypeError: sequence item 2: expected str instance, int found

Это лишь демонстрация того, что join нельзя использовать для объединения элементов разного типа. Только строковые значения.

Что бы избежать этой ошибки, превратите все элементы списка в строки:

names = ['Java', 'Python', 1]
names = [str(i) for i in names]

Разбитие строки с помощью join

Также функцию join() можно использовать, чтобы разбить строку по определенному разделителю.

>>> print(",".join("Python"))
P,y,t,h,o,n

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

Обратное преобразование строки в список

Помимо join() есть и функция split(), которая используется для разбития строки. Она работает похожим образом. Посмотрим на код:

names = ['Java', 'Python', 'Go']
delimiter = ','
single_str = delimiter.join(names)
print('Строка: {0}'.format(single_str))

split = single_str.split(delimiter)
print('Список: {0}'.format(split))

Вывод:

Строка: Java,Python,Go
Список: ['Java', 'Python', 'Go']

Вот и все что нужно знать об объединении и разбитии строк.

Если неправильно организовать отступы, пробелы или табуляции в программе, то вернется ошибка IndentationError: expected an intended block.

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

IndentationError: expected an indented block

Языки программирования, такие как C и JavaScript, не требуют отступов. В них для структуризации кода используются фигурные скобы. В Python этих скобок нет.

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

def find_average(grades):
average = sum(grades) / len(grades)
print(average)
return average

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

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

Пример возникновения ошибки отступа

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

Для начала создадим список всей еды:

lunch_menu = ["Бублик с сыром", "Сэндвич с сыром", "Cэндвич с огурцом", "Бублик с лососем"]

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

def get_bagels(menu):
bagels = []

    for m in menu:
        if "Бублик" in m:
            bagels.append(m)

    return bagels

get_bagels() принимает один аргумент — список меню, по которому она пройдется в поиске нужных элементов. Она проверяет, содержит ли элемент слово «Бублик», и в случае положительного ответа добавит его в новый список.

Наконец, функцию нужно вызвать и вывести результат:

bagels = get_bagels(lunch_menu)
print(bagels)

Этот код вызывает функцию get_bagels() и выводит список бубликов в консоль. Запустим код и посмотрим на результат:

  File "test.py", line 4
    bagels = []
    ^
IndentationError: expected an indented block

Ошибка отступа.

Решение ошибки IndentationError

Ошибка отступа сообщает, что отступ был установлен неправильно. Его нужно добавить на 4 строке. Посмотрим на код:

def get_bagels(menu):
bagels = []

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

def get_bagels(menu):
    bagels = []

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

['Бублик с сыром', 'Бублик с лососем']

Код нашел все бублики и добавил их в новый список. После этого вывел его в консоль.

Вывод

Ошибка IndentationError: expected an indented block возникает, если забыть добавить отступ в коде. Для исправления нужно проверить все отступы, которые должны присутствовать.

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

Оператор ** для возведения в степень

Многие разработчики считают, что символ карет (^) — это оператор возведения числа в степень, ведь именно он обозначает эту операцию в математике. Однако в большинстве языков программирования этот знак выступает в качестве побитового xor.

В Python оператор возведения в степень обозначается двумя символами звездочки ** между основанием и числом степени.

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

print(5**6)

Чтобы умножить число 5 само на себя 6 раз, используется ** между основанием 5 и операндом степени 6. Вывод:

15625

Проверим оператор с другими значениями.

Инициализируем целое число, отрицательное целое, ноль, два числа с плавающей точкой float, одно больше нуля, а второе — меньше. Степеням же присвоим случайные значения.

num1 = 2
num2 = -5
num3 = 0
num4 = 1.025
num5 = 0.5

print(num1, '^12 =', num1**12)
print(num2, '^4 =', num2**4)
print(num3, '^9999 =', num3**9999)
print(num4, '^-3 =', num4**-3)
print(num5, '^8 =', num5**8)

Вывод:

2 ^12 = 4096
-5 ^4 = 625
0 ^9999 = 0
1.025 ^-3 = 0.928599410919749
0.5 ^8 = 0.00390625

pow() или math.power() для возведения в степень

Также возводить в степень в Python можно с помощью функции pow() или модуля math, в котором есть своя реализация этого же модуля.

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

import math

print(pow(-8, 7))
print(math.pow(-8, 7))

print(pow(2, 1.5))
print(math.pow(2, 1.5))

print(pow(4, 3))
print(math.pow(4,3))

print(pow(2.0, 5))
print(math.pow(2.0, 5))

Вывод:

-2097152
-2097152.0
2.8284271247461903
2.8284271247461903
64
64.0
32.0
32.0

Отличие лишь в том, что math.pow() всегда возвращает значение числа с плавающей точкой, даже если передать целые числа. А вот pow() вернет число с плавающей точкой, если таким же был хотя бы один из аргументов.

numpy.np() для возведения в степень

В модуле numpy есть своя функция power() для возведения в степень. Она принимает те же аргументы, что и pow(), где первый — это основание, а второй — значение степени.

Выведем те же результаты.

print(np.power(-8, 7))
print(np.power(2, 1.5))
print(np.power(4, 3))
print(np.power(2.0, 5))

-2097152
2.8284271247461903
64
32.0

Как получить квадрат числа в Python?
Для возведения числа в квадрат, нужно указать 2 в качестве степени. Встроенной функции для получения квадрата в Python нет.
Например, квадрат числа 6 — 6**2 —> 36.

Сравнение времени работы разных решений

Теперь сравним, сколько занимает выполнение каждой из трех функций и оператора **. Для этого используем модуль timeit.

Основанием будет 2, а значением степени — 9999999.

import numpy as np
import math
import time

start = time.process_time()
val = 2**9999999
print('** за', time.process_time() - start, 'ms')

start = time.process_time()
val = pow(2, 9999999)
print('pow() за', time.process_time() - start, 'ms')

start = time.process_time()
val = np.power(2, 9999999)
print('np.power() за', time.process_time() - start, 'ms')

start = time.process_time()
val = math.pow(2, 9999999)
print('math.pow() за', time.process_time() - start, 'ms')

** за 0.078125 ms
pow() за 0.0625 ms
np.power() за 0.0 ms
Traceback (most recent call last):
  File "C:\Programs\Python\Python38\test.py", line 18, in <module>
    val = math.pow(2, 9999999)
OverflowError: math range error

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

Различия между остальными достаточно простые, но можно увидеть, что np.power() — самая быстрая.

В этом руководстве мы научимся считывать файл построчно, используя функции readline(), readlines() и объект файла на примерах различных программ.

Пример 1: Чтение файла построчно функцией readline()

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

Как использовать функцию file.readline()

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

1. Открываем файл в режиме чтения. При этом возвращается дескриптор файла.
2. Создаём бесконечный цикл while.
   1. В каждой итерации считываем строку файла при помощи readline().
   2. Если строка не пустая, то выводим её и переходим к следующей. Вы можете проверить это, используя конструкцию if not. В противном случае файл больше не имеет строк и мы останавливаем цикл с помощью break.
3. К моменту выхода из цикла мы считаем все строки файла в итерациях одну за другой.
4. После этого мы закрываем файл, используя функцию close.

# получим объект файла
file1 = open("sample.txt", "r")

while True:
    # считываем строку
    line = file1.readline()
    # прерываем цикл, если строка пустая
    if not line:
        break
    # выводим строку
    print(line.strip())

# закрываем файл
file1.close

Вывод:

Привет!
Добро пожаловать на PythonRu.
Удачи в обучении!

Пример 2: Чтение строк как список функцией readlines()

Функция readlines() возвращает все строки файла в виде списка. Мы можем пройтись по списку и получить доступ к каждой строке.

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

# получим объект файла
file1 = open("sample.txt", "r")

# считываем все строки
lines = file1.readlines()

# итерация по строкам
for line in lines:
    print(line.strip())

# закрываем файл
file1.close

Привет!
Добро пожаловать на PythonRu.
Удачи в обучении!

Пример 3: Считываем файл построчно из объекта File

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

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

Для демонстрации откроем файл с помощью with open. Это применимо и к предыдущим двум примерам.

# получим объект файла
with open("sample.txt", "r") as file1:
    # итерация по строкам
    for line in file1:
        print(line.strip())

Привет!
Добро пожаловать на PythonRu.
Удачи в обучении!

Выводы

В этом руководстве мы научились считывать текстовый файл построчно с помощью примеров программ на Python.

С другой стороны, переменная, объявленная внутри определенного блока кода, будет видна только внутри этого же блока — она называется локальной.

Разберемся с этими понятиями на примере.

Пример локальных и глобальных переменных

def sum():  
    a = 10   # локальные переменные 
    b = 20  
    c = a + b  
    print("Сумма:", c)  
  
sum() 

Вывод: Сумма: 30.

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

Для решения этой проблемы используются глобальные переменные.

Теперь взгляните на этот пример с глобальными переменными:

a = 20  # определены вне функции
b = 10  


def sum():  
    c = a + b  # Использование глобальных переменных  
    print("Сумма:", c)  

  
def sub():  
    d = a - b  # Использование глобальных переменных 
    print("Разница:", d)  
  
  
sum()
sub()

Вывод:

Сумма: 30
Разница: 10

В этом коде были объявлены две глобальные переменные: a и b. Они используются внутри функций sum() и sub(). Обе возвращают результат при вызове.

Если определить локальную переменную с тем же именем, то приоритет будет у нее. Посмотрите, как в функции msg это реализовано.

def msg():  
    m = "Привет, как дела?"  
    print(m)  
  
msg()  
m = "Отлично!"  # глобальная переменная
print(m) 

Вывод:

Привет, как дела?
Отлично!

Здесь была объявлена локальная переменная с таким же именем, как и у глобальной. Сперва выводится значение локальной, а после этого — глобальной.

Ключевое слово global

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

Правила использования global

• Если значение определено на выходе функции, то оно автоматически станет глобальной переменной.
• Ключевое слово global используется для объявления глобальной переменной внутри функции.
• Нет необходимости использовать global для объявления глобальной переменной вне функции.
• Переменные, на которые есть ссылка внутри функции, неявно являются глобальными.

Пример без использования глобального ключевого слова.

c = 10  


def mul():
    c = c * 10 
    print(c) 


mul() 

Вывод:

line 5, in mul
    c = c * 10
UnboundLocalError: local variable 'c' referenced before assignment

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

c = 10  


def mul():
    global c
    c = c * 10 
    print("Значение в функции:", c)  

mul()  
print("Значение вне функции:", c)  

Вывод:

Значение в функции: 100
Значение вне функции: 100

Здесь переменная c была объявлена в функции mul() с помощью ключевого слова global. Ее значение умножается на 10 и становится равным 100. В процессе работы программы можно увидеть, что изменение значения внутри функции отражается на глобальном значении переменной.

Глобальные переменные в модулях Python

Преимущество использования ключевого слова global — в возможности создавать глобальные переменные и передавать их между модулями. Например, можно создать name.py, который бы состоял из глобальных переменных. Если их изменить, то изменения повлияют на все места, где эти переменные встречаются.

1. Создаем файл name.py для хранения глобальных переменных:

a = 10 
b = 20 
msg = "Hello World"

2. Создаем файл change.py для изменения переменных:

import name

name.a = 15  
name.b = 25
name.msg = "Dood bye"  

Меняем значения a, b и msg. Эти переменные были объявлены внутри name, и для их изменения модуль нужно было импортировать.

3. В третий файл выводим значения измененных глобальных переменных.

import name
import change

print(name.a) 
print(name.b)
print(name.msg)

Значение изменилось. Вывод:

15
25
Dood bye

Global во вложенных функциях

Можно использовать ключевое слово global во вложенных функциях.

def add():
    a = 15
  
    def modify():
        global a
        a = 20

    print("Перед изменением:", a)
    print("Внесение изменений")
    modify()
    print("После изменения:", a)


add()
print("Значение a:", a)  

Вывод:

Перед изменением: 15
Внесение изменений
После изменения: 15
Значение a: 20

В этом коде значение внутри add() принимает значение локальной переменной x = 15. В modify() оно переназначается и принимает значение 20 благодаря global. Это и отображается в переменной функции add().

Функция input() возвращает все в виде строки, поэтому нужно выполнить явную конвертацию, чтобы получить целое число. Для этого пригодится функция int().

# вывод суммы двух чисел, введенных пользователем



num_1 = int(input("Введите первое число: "))

num_2 = int(input("Введите второе число: "))



print("Тип num_1:", type(num_1))

print("Тип num_2:", type(num_2))



result = num_1 + num_2

print("Сумма введенных чисел:", result)

int(string) конвертирует переданную строку в целое число.

Ввода числа float

По аналогии можно использовать функцию float().

float_1 = float(input("Введите число: "))

print("Тип float_1:", type(float_1))



result = float_1 ** 2

print("Число в квадрате:", result)

Вывод примера:

Введите число: 1.8
Тип float_1: <class 'float'>
Число в квадрате: 3.24

Ввод чисел в строку через пробел

Но что произойдет, если вы не знаете количество элементов ввода?

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

Для этого можно использовать split и функции map. Метод split() делит введенную строку на список подстрок. После этого map() выполняет функцию int() для каждого элемента списка.

entered_list = input("Введите список чисел, разделенных пробелом: ").split()

print("Введенный список:", entered_list)



num_list = list(map(int, entered_list))

print("Список чисел: ", num_list)

print("Сумма списка:", sum(num_list))

Введите список чисел, разделенных пробелом: 1 34 4 6548
Введенный список: ['1', '34', '4', '6548']
Список чисел:  [1, 34, 4, 6548]
Сумма списка: 6587

В коде выше:

• input() возвращает список, содержащий числа, разделенные запятыми.
• split() возвращает список строк, разделенных пробелами.
• map() выполняет операцию int() для всех элементов списка и возвращает объект map.
• list() конвертирует объект map снова в список.

Есть альтернативный способ получить список:

entered_list = input("Введите список чисел, разделенных пробелом: ").split()



num_list = [int(i) for i in entered_list]

print("Список чисел: ", num_list)

Обработка ошибок при пользовательском вводе

Часто при конвертации типов возникает исключение ValueError.

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

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

num = int(input("Введите возраст: "))

Функция int() ожидает целочисленное значение, обернутое в строку. Любое другое значение приводит к ошибке. Вот что будет, если, попробовать ввести «Двадцать»:

Введите возраст: Двадцать
---------------------------------------------------------
ValueError                    Traceback (most recent call last)
<ipython-input-10-1fa1cb611d10> in <module>
----> 1 num_1 = int(input('Введите возраст: '))

ValueError: invalid literal for int() with base 10: 'Двадцать'

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

try:

    num = int(input("Введите число: "))

    print("Все верно. Число:", num)

except ValueError:

    print("Это не число.")

Посмотрим, как ввод «Двадцать» сработает теперь:

Введите число: Двадцать
Это не число.

В этом примере если пользователь вводит нечисловое значение, то возникает исключение. Однако оно перехватывается инструкцией except, которая в ответ выводит: «Это не число». Благодаря использованию конструкции try-except программа не прекратит работать при некорректном вводе.

• Рекурсивную функцию поиска факториала.
• Как рекурсивные функции работают в коде.
• Действительно ли рекурсивные функции выполняют свои задачи лучше итеративных?

Рекурсивные функции

Рекурсивная функция — это та, которая вызывает сама себя.

В качестве простейшего примера рассмотрите следующий код:

def factorial_recursive(n):

    if n == 1:

        return n

    else:

        return n*factorial_recursive(n-1)

Вызывая рекурсивную функцию здесь и передавая ей целое число, вы получаете факториал этого числа (n!).

Вкратце о факториалах

Факториал числа — это число, умноженное на каждое предыдущее число вплоть до 1.

Например, факториал числа 7:
7! = 7*6*5*4*3*2*1 = 5040

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

num = 3

print(f"Факториал {num} это {factorial_recursive(num)}")

Эта функция выведет: «Факториал 3 это 6». Еще раз рассмотрим эту рекурсивную функцию:

def factorial_recursive(n):

    ...

По аналогии с обычной функцией имя рекурсивной указывается после def, а в скобках обозначается параметр n:

def factorial_recursive(n):
    if n == 1:
        return n
    else:
        return n*factorial_recursive(n-1)

Благодаря условной конструкции переменная n вернется только в том случае, если ее значение будет равно 1. Это еще называют условием завершения. Рекурсия останавливается в момент удовлетворения условиям.

def factorial_recursive(n):
    if n == 1:
        return n
    else:
        return n*factorial_recursive(n-1)

В коде выше выделен фрагмент самой рекурсии. В блоке else условной конструкции возвращается произведение n и значения этой же функции с параметром n-1.

Это и есть рекурсия. В нашем примере это так сработало:

3 * (3-1) * ((3-1)-1)  # так как 3-1-1 равно 1, рекурсия остановилась

Детали работы рекурсивной функции

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

Для этого ниже представим каждый экземпляр с реальными числами. Это поможет «отследить», что происходит при вызове одной функции со значением 3 в качестве аргумента:

# Первый вызов

factorial_recursive(3):

    if 3 == 1:

        return 3

    else:

        return 3*factorial_recursive(3-1)



# Второй вызов

factorial_recursive(2):

    if 2 == 1:

        return 2

    else:

        return 2*factorial_recursive(2-1)



# Третий вызов

factorial_recursive(1):

    if 1 == 1:

        return 1

    else:

        return 1*factorial_recursive(1-1)

Рекурсивная функция не знает ответа для выражения 3*factorial_recursive(3–1), поэтому она добавляет в стек еще один вызов.

Как работает рекурсия

/\ factorial_recursive(1) - последний вызов
|| factorial_recursive(2) - второй вызов
|| factorial_recursive(3) - первый вызов

Выше показывается, как генерируется стек. Это происходит благодаря процессу LIFO (last in, first out, «последним пришел — первым ушел»). Как вы помните, первые вызовы функции не знают ответа, поэтому они добавляются в стек.

Но как только в стек добавляется вызов factorial_recursive(1), для которого ответ имеется, стек начинает «разворачиваться» в обратном порядке, выполняя все вычисления с реальными значениями. В процессе каждый из слоев выпадает в процессе.

• factorial_recursive(1) завершается, отправляет 1 в
• factorial_recursive(2) и выпадает из стека.
• factorial_recursive(2) завершается, отправляет 2*1 в
• factorial_recursive(3) и выпадает из стека. Наконец, инструкция else здесь завершается, возвращается 3 * 2 = 6, и из стека выпадает последний слой.

Рекурсия в Python имеет ограничение в 3000 слоев.

>>> import sys

>>> sys.getrecursionlimit()

3000

Рекурсивно или итеративно?

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

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

Рекурсия может быть медленной, если реализована неправильно

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

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

def factorial_iterative(num):

    factorial = 1

    if num < 0:

        print("Факториал не вычисляется для отрицательных чисел")

    else:

        for i in range (1, num + 1):

            factorial = factorial*i

        print(f"Факториал {num} это {factorial}")

Синтаксис

string.find(substring,start,end)

Метод find принимает три параметра:

• substring (символ/подстрока) — подстрока, которую нужно найти в данной строке.
• start (необязательный) — первый индекс, с которого нужно начинать поиск. По умолчанию значение равно 0.
• end (необязательный) — индекс, на котором нужно закончить поиск. По умолчанию равно длине строки.

Поиск символов методом find() со значениями по умолчанию

Параметры, которые передаются в метод, — это подстрока, которую требуются найти, индекс начала и конца поиска. Значение по умолчанию для начала поиска — 0, а для конца — длина строки.

В этом примере используем метод со значениями по умолчанию.

Метод find() будет искать символ и вернет положение первого совпадения. Даже если символ встречается несколько раз, то метод вернет только положение первого совпадения.

>>> string = "Добро пожаловать!"

>>> print("Индекс первой буквы 'о':", string.find("о"))

Индекс первой буквы 'о': 1

Поиск не с начала строки с аргументом start

Можно искать подстроку, указав также начальное положение поиска.

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

>>> string = "Специалисты назвали плюсы и минусы Python"

>>> print("Индекс подстроки 'али' без учета первых 8 символов:", string.find("али", 8))

Индекс подстроки 'али' без учета первых 8 символов: 16

Поиск символа в подстроке со start и end

С помощью обоих аргументов (start и end) можно ограничить поиск и не проводить его по всей строке. Найдем индексы слова «пожаловать» и повторим поиск по букве «о».

>>> string = "Добро пожаловать!"

>>> start = string.find("п")

>>> end = string.find("ь") + 1

>>> print("Индекс первой буквы 'о' в подстроке:", string.find("о", start, end))

Индекс первой буквы 'о' в подстроке: 7

Проверка есть ли символ в строке

Мы знаем, что метод find() позволяет найти индекс первого совпадения подстроки. Он возвращает -1 в том случае, если подстрока не была найдена.

>>> string = "Добро пожаловать!"

>>> print("Есть буква 'г'?", string.find("г") != -1)

Есть буква 'г'? False

>>> print("Есть буква 'т'?", string.find("т") != -1)

Есть буква 'т'? True

Поиск последнего вхождения символа в строку

Функция rfind() напоминает find(), а единое отличие в том, что она возвращает максимальный индекс. В обоих случаях же вернется -1, если подстрока не была найдена.

В следующем примере есть строка «Добро пожаловать!». Попробуем найти в ней символ «о» с помощью методов find() и rfind().

>>> string = "Добро пожаловать"

>>> print("Поиск 'о' методом find:", string.find("о"))

Поиск 'о' методом find: 1

>>> print("Поиск 'о' методом rfind:", string.rfind("о"))

Поиск 'о' методом rfind: 11

Вывод показывает, что find() возвращает индекс первого совпадения подстроки, а rfind() — последнего совпадения.

Второй способ поиска — index()

Метод index() помогает найти положение данной подстроки по аналогии с find(). Единственное отличие в том, что index() бросит исключение в том случае, если подстрока не будет найдена, а find() просто вернет -1.

Вот рабочий пример, показывающий разницу в поведении index() и find():

>>> string = "Добро пожаловать"

>>> print("Поиск 'о' методом find:", string.find("о"))

Поиск 'о' методом find: 1

>>> print("Поиск 'о' методом index:", string.index("о"))

Поиск 'о' методом index: 1

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

>>> string = "Добро пожаловать"

>>> print("Поиск 'г' методом find:", string.find("г"))

Поиск 'г' методом find: 1

>>> print("Поиск 'г' методом index:", string.index("г"))

Traceback (most recent call last):

  File "pyshell#21", line 1, in module

    print("Поиск 'г' методом index:", string.index("г"))

ValueError: substring not found

В этом примере мы пытались найти подстроку «г». Ее там нет, поэтому find() возвращает -1, а index() бросает исключение.

Поиск всех вхождений символа в строку

Чтобы найти общее количество совпадений подстроки в строке можно использовать ту же функцию find(). Пройдемся циклом while по строке и будем задействовать параметр start из метода find().

Изначально переменная start будет равна -1, что бы прибавлять 1 у каждому новому поиску и начать с 0. Внутри цикла проверяем, присутствует ли подстрока в строке с помощью метода find.

Если вернувшееся значение не равно -1, то обновляем значением count.

Вот рабочий пример:

my_string = "Добро пожаловать"

start = -1

count = 0



while True:

    start = my_string.find("о", start+1)

    if start == -1:

        break

    count += 1



print("Количество вхождений символа в строку: ", count )

Количество вхождений символа в строку:  4

Выводы

• Метод find() помогает найти индекс первого совпадения подстроки в данной строке. Возвращает -1, если подстрока не была найдена.
• В метод передаются три параметра: подстрока, которую нужно найти, start со значением по умолчанию равным 0 и end со значением по умолчанию равным длине строки.
• Можно искать подстроку в данной строке, задав начальное положение, с которого следует начинать поиск.
• С помощью параметров start и end можно ограничить зону поиска, чтобы не выполнять его по всей строке.
• Функция rfind() повторяет возможности find(), но возвращает максимальный индекс (то есть, место последнего совпадения). В обоих случаях возвращается -1, если подстрока не была найдена.
• index() — еще одна функция, которая возвращает положение подстроки. Отличие лишь в том, что index() бросает исключение, если подстрока не была найдена, а find() возвращает -1.
• find() можно использовать в том числе и для поиска общего числа совпадений подстроки.

В этой статье рассмотрим самые популярные встроенные функции Python. Для каждой из них будет представлено описание и один пример. Примеры выполняются в консоли Python Shell.

1. abs()

Функция abs() в Python возвращает абсолютное значение числа. Если это комплексное число, то абсолютным значением будет величина целой и мнимой частей.

>>> abs(-5.6)

5.6

2. chr()

Функция chr() возвращает строку, представляющую символ Unicode для переданного числа. Она является противоположностью ord(), которая принимает символ и возвращает его числовой код.

>>> chr(97)

'a'

3. callable()

Вызываемый объект — это объект, который можно вызвать. Функция callable() сообщает, является ли объект вызываемым. Если да, то возвращает True, а в противном случае — False.

>>> callable(5)

False

4. complex()

Комплексное число — это число, представленное в форме a + bi. Оно принимает целые числа или строки и возвращает соответствующее комплексное число. Если передать неподходящее значение, то вернется ошибка ValueError.

>>> complex(3)

(3+0j)



>>> complex(-3,-2)

(-3-2j)

5. dict()

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

>>> dict({"a":1, "b":2}, c = 3)

{'a': 1, 'b': 2, 'c': 3}

 

>>> list = [["a",1],["b",2]]

>>> dict(list)

{'a': 1, 'b': 2}

6. dir()

Функция dir() получает список вех атрибутов и методов объекта. Если объект не передать, то функция вернет все имена модулей в локальном пространстве имен.

>>> x = ["Яблоко", "Апельсин", "Гранат"]

>>> print(dir(x))

['__add__', '__class__', '__contains__',....]

7. enumerate()

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

>>> x = "Строка"

>>> list(enumerate(x))

[(0, 'С'), (1, 'т'), (2, 'р'), (3, 'о'), (4, 'к'), (5, 'а')]

8. eval()

eval() обрабатывает переданное в нее выражение и исполняет его как выражение Python. После этого возвращается значение. Чаще всего эта функция используется для выполнения математических функций.

>>> eval('2+2')

4

>>> eval('2*7')

14

>>> eval('5/2')

2.5

9. filter()

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

list1 = [3, 5, 4, 8, 6, 33, 22, 18, 76, 1]

result = list(filter(lambda x: (x%2 != 0) , list1))

print(result)

10. float()

Эта встроенная функция конвертирует число или строку в число с плавающей точкой и возвращает результат. Если из-за некорректного ввода конвертация не проходит, возвращаются ValueError или TypeError.

>>> float('596')

596.0
>>> float(26)

26.0

11. hash()

У большинства объектов в Python есть хэш-номер. Функция hash() возвращает значение хэша переданного объекта. Объекты с __hash__() — это те, у которых есть соответствующее значение.

>>> hash('Hello World')

-2864993036154377761
>>> hash(True)

1

12. help()

Функция help() предоставляет простой способ получения доступа к документации Python без интернета для любой функции, ключевого слова или модуля.

>>> help(print)

Help on built-in function print in module builtins:



print(...)

    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)


 

    Prints the values to a stream, or to sys.stdout by default.

    Optional keyword arguments:

    file:  a file-like object (stream); defaults to the current sys.stdout.

    sep:   string inserted between values, default a space.

    end:   string appended after the last value, default a newline.

    flush: whether to forcibly flush the stream.

13. input()

Функция input() — это быстрый и удобный способ получить данные от пользователя. Вызов этой функции предоставляет пользователю возможность ввести на экране текст. Затем он конвертируется в строку и возвращается в программу.

>>> value = input("Пожалуйста, введите значение: ")

Пожалуйста, введите значение: 123

>>> value

'123'

14. int()

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

>>> int(5.6)

5



>>> int('0101', 2)

5

15. iter()

Эта функция принимает объект и возвращает итерируемый объект. Сам по себе он бесполезен, но оказывается крайне эффективным при использовании в циклах for и while. Благодаря этому объект можно перебирать по одному свойству за раз.

>>> lis = ['a', 'b', 'c', 'd', 'e']

>>> x = iter(lis)

>>> next(x)

'a'

>>> next(x)

'b'

>>> next(x)

'c'

>>> next(x)

'd'

16. max()

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

>>> max('a', 'A')

'a'



>>> x = [5, 7, 8, 2, 5]

>>> max(x)

8



>>> x = ["Яблоко", "Апельсин", "Автомобиль"]

>>> max(x, key = len)

'Яблоко'

17. min()

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

>>> min('a','A')

'A'



>>> x = [5, 7, 8, 2, 5]

>>> min(x)

2



>>> x = ["Виноград", "Манго", "Фрукты", "Клубника"]

>>> min(x)

'Виноград'

18. len()

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

>>> x = (2, 3, 1, 6, 7)

>>> len(x)

5

>>> len("Строка")

6

19. list()

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

>>> list("Привет")

['П', 'р', 'и', 'в', 'е', 'т']



>>> list({1:"a", 2:"b", 3:"c"})

[1, 2, 3]

20. map()

Используется для применения определенной функции к итерируемому объекту. Она возвращает результат в виде итерируемого объекта (списки, кортежи, множества). Можно передать и несколько объектов, но в таком случае нужно будет и соответствующее количество функций.

>>> def inc(x):

            x = x + 1

            return x



>>> lis = [1,2,3,4,5]

>>> result = map(inc,lis)



>>> for x in result:

            print(x)



2

3

4

5

6

21. next()

Используется для итерируемых объектов. Умеет получать следующий (next) элемент в последовательности. Добравшись до конца, выводит значение по умолчанию.

>>> lis = ['a', 'b', 'c', 'd', 'e']

>>> x = iter(lis)

>>> next(x)

'a'

>>> next(x)

'b'

>>> next(x)

'c'

>>> next(x)

'd'

22. ord()

Функция ord() принимает один символ или строку длиной в один символ и возвращает соответствующее значение Unicode. Например, ord("a") вернет 97, а 97 — a.

>>> ord('a')

97



>>> ord('A')

65

23. reversed()

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

>>> x = [3,4,5]

>>> b = reversed(x)

>>> list(b)

[5, 4, 3]

24. range()

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

>>> list(range(10,20,2))

[10, 12, 14, 16, 18]

25. reduce()

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

>>> list1 = [2, 5, 3, 1, 8]

>>> functools.reduce(operator.add,list1)

19



>>> list1 = [2, 5, 3, 1, 8]

>>> functools.reduce(operator.mul,list1)

240



>>> list1 = [2, 5, 3, 1, 8]

>>> functools.reduce(operator.truediv,list1)

0.016666666666666666

26. sorted()

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

>>> X = [4, 5, 7, 3, 1]

>>> sorted(X)

[1, 3, 4, 5, 7]

27. str()

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

>>> str(5)

'5'



>>> X = [5,6,7]

>>> str(X)

'[5, 6, 7]'

28. set()

Функция set() используется для создания наборов данных, которые передаются в качестве параметра. Обычно это последовательность, например строка или список, которая затем преобразуется в множество уникальных значений.

>>> set()

set()



>>> set("Hello")

{'e', 'l', 'o', 'H'}



>>> set((1,2,3,4,5))

{1, 2, 3, 4, 5}

29. sum()

Вычисление суммы — стандартная задача во многих приложениях. И для этого в Python есть встроенная функция. Она автоматически суммирует все элементы и возвращает сумму.

>>> x = [1, 2, 5, 3, 6, 7]

>>> sum(x)

24

30. tuple()

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

>>> tuple("Привет")

('П', 'р', 'и', 'в', 'е', 'т')



>>> tuple([1, 2, 3, 4, 5])

(1, 2, 3, 4, 5)

31. type()

Функция type применяется в двух сценариях. Если передать один параметр, то она вернет тип этого объекта. Если же передать три параметра, то можно создать объект type.

>>> type(5)

<class 'int'>



>>> type([5])

<class 'list'>

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

• int (целые числа)
• float (числа с плавающей точкой)
• complex (комплексные числа)

Хотя int и float присутствуют в большинстве других языков программирования, наличие типа комплексных чисел — уникальная особенность Python. Теперь рассмотрим в деталях каждый из типов.

Целые и числа с плавающей точкой в Python

В программирование целые числа — это те, что лишены плавающей точкой, например, 1, 10, -1, 0 и так далее. Числа с плавающей точкой — это, например, 1.0, 6.1 и так далее.

Создание int и float чисел

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

var1 = 25

Здесь мы присваиваем значение 25 переменной var1. Важно не использовать одинарные или двойные кавычки при создании чисел, поскольку они отвечают за представление строк. Рассмотрим следующий код.

var1 = "25"

# или

var1 = '25'

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

var1 = 0.001

Здесь также не стоит использовать кавычки.

Проверить тип данных переменной можно с помощью встроенной функции type(). Можете проверить результат выполнения, скопировав этот код в свою IDE.

var1 = 1  # создание int

var2 = 1.10  # создание float

var3 = "1.10"  # создание строки

print(type(var1))

print(type(var2))

print(type(var3))

Вывод:

<class 'int'>
<class 'float'>
<class 'str'>

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

# создание 1,000,000

var1 = 1,000,000  # неправильно

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

# создание 1,000,000

var1 = 1_000_000  # правильно

print(var1)

Значение выведем с помощью функции print:

1000000

Арифметические операции над целыми и числами с плавающей точкой

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

Сложение

В Python сложение выполняется с помощью оператора +. В терминале Python выполните следующее.

>>> 1+3

Результатом будет сумма двух чисел, которая выведется в терминале.

Теперь запустим такой код.

>>> 1.0 + 2
3.0

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

Вычитание

В Python для операции вычитания используется оператор -. Рассмотрим примеры.

>>> 3 - 1
2
>>> 1 - 5
-4
>>> 3.0 - 4.0
-1.0
>>> 3 - 1.0
2.0

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

Умножение

Для умножения в Python применяется оператор *.

>>> 8 * 2
16
>>> 8.0 * 2
16.0
>>> 8.0 * 2.0
16.0

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

Деление

В Python деление выполняется с помощью оператора /.

>>> 3 / 1
3.0
>>> 4 / 2
2.0
>>> 3 / 2
1.5

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

>>> 1 / 0
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

Деление без остатка

При обычном делении с использованием оператора / результатом будет точное число с плавающей точкой. Но иногда достаточно получить лишь целую часть операции. Для этого есть операции интегрального деления. Стоит рассмотреть ее на примере.

>>> 2 // 1
2
>>> 4 // 3
1
>>> 5 // 2
2

Результатом такой операции становится частное. Остаток же можно получить с помощью модуля, о котором речь пойдет дальше.

Остаток от деления

Для получения остатка деления двух чисел используется оператор деления по модулю %.

>>> 5 % 2
1
>>> 4 % 2
0
>>> 3 % 2
1
>>> 5 % 3
2

На этих примерах видно, как это работает.

Возведение в степень

Число можно возвести в степень с помощью оператора **.

>>> 3**2
9
>>> 2**4
16
>>> 3**3
27

Комплексные числа

Комплексные числа — это числа, которые включают мнимую часть. Python поддерживает их «из коробки». Их можно запросто создавать и использовать. Пример:

# создание двух комплексных чисел

var1 = 2 + 2j

var2 = 3 + 4j

# сложение двух комплексных чисел

sum = var1 + var2

print("Сумма двух комплексных чисел равна: ", sum)

В этом примере были созданы два комплексных числа a+bj. После этого было выполнено их сложение с помощью оператора +. Результат вывели на экран с помощью функции print().

Сумма двух комплексных чисел равна: (5+6j)

Конвертация типов чисел

Конвертация типа — это метод конвертации числа из одного типа в другой. Для этого можно использовать функции float(), int() и complex().

x = 1  # создание целого числа

y = 2.0  # создание числа с плавающей точкой

z = 2+3j  # создание комплексного числа



a = float(x)  # преобразование целого числа в число с плавающей точкой

b = int(x)  # преобразование числа с плавающей точкой в ​​целое число

c = complex(x)  # преобразование целого числа в комплексное

d = complex(y)  # преобразование числа с плавающей точкой в комплексное



print(a, type(a))

print(b, type(b))

print(c, type(c))

print(d, type(d))

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

1.0 <class 'float'>
1 <class 'int'>
(1+0j) <class 'complex'>
(2+0j) <class 'complex'>

Случайные числа

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

import random

print(random.randrange(1, 1000))

Результатом будет новое число от 1 до 1000, у каждого свое.

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

В Python есть множество встроенных функций для работы с числами. Вот самые важные из них.

round()

Функция round() используется для округления чисел с плавающей точкой до ближайшего целого. Пр этом тип данных не меняется. Целое число — это также число с плавающей точкой. Пример:

# создание чисел

a = 0.01

b = 1.45

c = 2.25

d = 3.7

e = 4.5



# округление чисел

print(round(a))

print(round(b))

print(round(c))

print(round(d))

print(round(e))

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

0
1
2
4
4

abs()

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

# создание чисел

a = 1.1

b = -1.5

c = 2

d = -3

e = 0



# отображение абсолютного значения

print(round(a))

print(round(b))

print(round(c))

print(round(d))

print(round(e))

Вывод:

1.1
1.5
2
3
0

pow()

Функция pow() используется для возведения числа в степень. Она повторяет то, что можно сделать и с помощью оператора **.

Функции pow() нужно передать два параметра. Первый — число, которое нужно возвести в степень, а второе — сама степень. Пример:

base = 8

power = 2



print(pow(base, power))

Возведем 8 в степень 2. Вывод:

64

Библиотека math

В Python есть полноценная библиотека, с помощью которой можно выполнять почти любую математическую операцию — math. Все это есть в стандартной библиотеке, поэтому дополнительные действия выполнять не нужно. В модуле есть кое-какие константы, среди которых PI, e и так далее. Есть и кое-какие математические методы: log(), exp(), sqrt(), тригонометрические функции и так далее.

Выводы

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

Важно и то, что в Python этот процесс очень простой.

Как создать файл в Python в три строки

С помощью следующего кода можно создать файл с названием BabyFile.txt и записать в него текст «Привет, файл!»:

my_file = open("BabyFile.txt", "w+")

my_file.write("Привет, файл!")

my_file.close()

В начале объявляется переменная my_file. После этого используются встроенные функции open и write для открытия и записи в файл. "w+" сообщает, что запись будет осуществляться в новый файл. Если он существует, то новое содержимое нужно записать поверх уже существующего. Если же вместо этого использовать параметр "w", тогда файл будет создан только в том случае, если он не существовал до этого.

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

Как записывать, добавляя новое содержимое

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

Если нужно добавить новые данные в файл, тогда вместо "w+" нужно просто использовать параметр "a+".

my_file = open("BabyFile.txt", "a+")

my_file.write("и еще кое-что!")

my_file.close()

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

Для чтения же файла нужно выполнить такую команду:

my_file = open("BabyFile.txt", "a+")

file_contents == my_file.read()

print(file_contents)

Привет, файл!и еще кое-что!

Удаление и перемещение файлов

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

Для этого используется модуль os, который также по умолчанию доступен в Python. Достаточно лишь импортировать его и можно приступать к использованию — для этого используются path и методы isfile(), isdir() или exists().

os.path.isfile("/путь/к/файлу")

С помощью этого модуля можно даже переименовывать файлы. Это просто:

os.rename("/путь/к/файлу", "/новый_путь/к/переименованному_файлу")

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

shutil.move("/путь/к/файлу", "/новый_путь/к/переименованному_файлу")

Наконец, для удаления файлов используется os.remove().

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

Краткий итог

Сортировка строк осуществляется по ASCII-значениям.

• Возвращаемое значение — List (список).
• Синтаксис: sorted(iterable,key=None,reverse=False).
• iterable: строка, список, кортеж, множество, словарь
• key (необязательный параметр): если указать ключ, то сортировка будет выполнена по функции этого ключа.
• reverse (необязательный параметр): по умолчанию сортировка выполняется по возрастанию. Если указать reverse=True, то можно отсортировать по убыванию.

# Сортировка строки

s2="hello"

print(sorted(s2))  # Вывод:['e', 'h', 'l', 'l', 'o']

print(sorted(s2, reverse=True))   # Вывод:['o', 'l', 'l', 'h', 'e']



# Сортировка списка

l1=[1, 4, 5, 2, 456, 12]

print(sorted(l1))   # Вывод:[1, 2, 4, 5, 12, 456]

print(sorted(l1, reverse=True))   # Вывод:[456, 12, 5, 4, 2, 1]



# Сортировка кортежа

t1=(15, 3, 5, 7, 9, 11, 42)

print(sorted(t1))   # Вывод:[3, 5, 7, 9, 11, 15, 42]

print(sorted(t1, reverse=True))   # Вывод:[42, 15, 11, 9, 7, 5, 3]



# Сортировка списка кортежей

t2=[(1, 2), (11, 12), (0, 2), (3, 2)]

print(sorted(t2))   # Вывод:[(0, 2), (1, 2), (3, 2), (11, 12)]

print(sorted(t2, reverse=True))   # Вывод:[(11, 12), (3, 2), (1, 2), (0, 2)]



# Сортировка множества

s1={1, 4, 3, 6, 2, 8, 11, 32}

print(sorted(s1))   # Вывод:[1, 2, 3, 4, 6, 8, 11, 32]

print(sorted(s1, reverse=True))   # Вывод:[32, 11, 8, 6, 4, 3, 2, 1]



# Сортировка словаря

d1={2: 'red', 1: 'green', 3: 'blue'}

# Вернется список отсортированных ключей

print(sorted(d1))   # Вывод:[1, 2, 3]



# Вернется список отсортированных значений

print(sorted(d1.values()))   # Вывод:['blue', 'green', 'red']



# Вернется список кортежей (ключ, значение), отсортированный по ключам.

print(sorted(d1.items()))   # Вывод:[(1, 'green'), (2, 'red'), (3, 'blue')]



# Сортировка словаря в обратном порядке

print(sorted(d1, reverse=True))   # Вывод:[3, 2, 1]

print(sorted(d1.values(), reverse=True))   # Вывод:['red', 'green', 'blue']

print(sorted(d1.items(), reverse=True))   # Вывод:[(3, 'blue'), (2, 'red'), (1, 'green')]

Параметр key

Итерируемый объект можно также отсортировать по функции, указанной в параметре key. Это может быть:

• Встроенная функция,
• Определенная пользователем функция,
• Лямбда-функция,
• itemgetter,
• attrgetter.

1. Встроенная функция

len()— посчитает длину объекта. Если указать len в виде параметра key, то сортировка будет выполнена по длине.

# Сортировка словаря на основе функции len

l1 = {'carrot': 'vegetable', 'red': 'color', 'apple': 'fruit'}

# Возвращает список ключей, отсортированных по функции len

print(sorted(l1, key=len))

# Вывод: ['red', 'apple', 'carrot']



# Возвращает список значений, отсортированных на основе функции len

print(sorted(l1.values(), key=len))

# Вывод: ['fruit', 'color', 'vegetable']



# Сортировка списка на основе функции len

l1 = ['blue', 'green', 'red', 'orange']

print(sorted(l1, key=len))

# Вывод: ['red', 'blue', 'green', 'orange']

abs() вернет абсолютно значение числа. Если задать abs для key, то сортировка будет основана на абсолютном значении.

# Сортировка списка по абсолютному значению

l1 = [1, -4, 5, -7, 9, 2]

print(sorted(l1, key=abs))

# Вывод: [1, 2, -4, 5, -7, 9]

str.lower() — конвертирует все символы в верхнем регистре в нижний регистр. В таком случае список будет отсортирован так, будто бы все символы в нижнем регистре.

s1 = "Hello How are you"



# Разбивает строку и сортирует по словам

print(sorted(s1.split()))

# Вывод: ['Hello', 'How', 'are', 'you']



# Разбивает строку и сортирует после применения str.lower ко всем элементам

print(sorted(s1.split(), key=str.lower))

# Вывод: ['are', 'Hello', 'How', 'you']



d1 = {'apple': 1, 'Banana': 2, 'Pears': 3}

# Возвращает список ключей, отсортированный по значениям

print(sorted(d1))

# Вывод: ['Banana', 'Pears', 'apple']



# Возвращает список ключей, отсортированный после применения str.lower ко всем элементам

print(sorted(d1, key=str.lower))

# Вывод: ['apple', 'Banana', 'Pears']

2. Пользовательские функции

Также можно указывать свои функции.

Пример №1: по умолчанию сортировка кортежа происходит по первому элементу в нем. Добавим функцию, которая будет возвращать второй элемент кортежа. Теперь и сортировка будет опираться на соответствующий элемент.

# напишем функцию для получения второго элемента

def sort_key(e):

    return e[1]



l1 = [(1, 2, 3), (2, 1, 3), (11, 4, 2), (9, 1, 3)]

# По умолчанию сортировка выполняется по первому элементу

print(sorted(l1))

# Вывод: [(1, 2, 3), (2, 1, 3), (9, 1, 3), (11, 4, 2)]



# Сортировка по второму элементу с помощью функции sort_key

print(sorted(l1, key=sort_key))

# Вывод: [(2, 1, 3), (9, 1, 3), (1, 2, 3), (11, 4, 2)]

Пример №2: можно сортировать объекты класса с помощью функций. Вот как это происходит:

• У класса Studen есть три атрибута: name, rollno, grade.
• Создаются три объекта этого класса: s1, s2, s3.
• Создается список s4, который содержит все три объекта.
• Дальше происходит сортировка по этому списку.
• Определенная функция (sort_key) возвращает атрибут rollno.
• В функции sorted эта функция задана для параметра key.
• Теперь sorted() возвращает список объектов Student, которые отсортированы по значению rollno.

class Student:

    def __init__(self, name, rollno, grade):

        self.name = name

        self.rollno = rollno

        self.grade = grade



    def __repr__(self):

        return f"{self.name}-{self.rollno}-{self.grade}"



# Создание объектов

s1 = Student("Paul", 15, "second")

s2 = Student("Alex", 12, "fifth")

s3 = Student("Eva", 21, "first")

s4 = [s1, s2, s3]



# Сортировка списка объектов

# Создание функции, которая вернет rollno объекта

def sort_key(s):

    return s.rollno



# сортировка списка объектов без ключевого параметра, вызывает TypeError

print(sorted(s4))

# Вывод: TypeError: '>' not supported between instances of 'Student' and 'Student'



# Сортировка списка объектов по атрибуту: rollno

s5 = sorted(s4, key=sort_key)

print(s5)

# Вывод: [Alex-12-fifth, Paul-15-second, Eva-21-first]

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

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

Пример №1: сортировка списка объектов класса на основе лямбда-функции, переданной для параметра key.

class Student:

    def __init__(self, name, rollno, grade):

        self.name = name

        self.rollno = rollno

        self.grade = grade



    def __repr__(self):

        return f"{self.name}-{self.rollno}-{self.grade}"



# Создание объектов

s1 = Student("Paul", 15, "second")

s2 = Student("Alex", 12, "fifth")

s3 = Student("Eva", 21, "first")

s4 = [s1, s2, s3]



# Сортировка списка объектов

# Создание lambda-функции, которая вернет rollno объекта

s5 = sorted(s4, key=lambda x: x.rollno)

print(s5)

# Вывод: [Alex-12-fifth, Paul-15-second, Eva-21-first]

Пример №2: сортировка кортежей по второму элементу. Лямбда-функция просто возвращает его для каждого переданного объекта.

l1 = [( 1, 2, 3), (3, 1, 1), (8, 5, 3), (3, 4, 2)]



# Сортировка по второму элементу в кортеже.

# Lambda-функция возвращает второй элемент в кортеже.

print(sorted(l1, key=lambda x: x[1]))

# Вывод: [(3, 1, 1), (1, 2, 3), (3, 4, 2), (8, 5, 3)]

4. itemgetter

operator — это встроенный модуль, включающий много операторов. itemgetter(n) создает функцию, которая принимает итерируемый объект (список, кортеж, множество) и возвращает n-элемент из него.

Пример №1: сортировка списка кортежей по третьему элементу в каждом из них. itemgetter() возвращает функцию, которая получает третий элемент в кортеже. По умолчанию если key не указать, то сортировка будет выполнена по первому элементу кортежа.

from operator import itemgetter



l1 = [(1, 2, 3), (3, 1, 1), (8, 5, 3), (3, 4, 2)]



# Сортировка по третьему элементу в кортеже

print(sorted(l1, key=itemgetter(2)))

# Вывод: [(3, 1, 1), (1, 2, 3), (3, 4, 2), (8, 5, 3)]

Пример №2: сортировка списка словарей по ключу age.

from operator import itemgetter



# Создание списка словарей

d1 = [{'name': 'Paul', 'age': 30},

         {'name': 'Alex', 'age': 7},

         {'name': 'Eva', 'age': 3}]



# Сортировка по key(age) в словаре

print(sorted(d1, key=itemgetter('age')))

# Вывод: [{'name': 'Eva', 'age': 3}, {'name': 'Alex', 'age': 7}, {'name': 'Paul', 'age': 30}]

Пример №3: сортировка значений словаря с помощью itemgetter.

from operator import itemgetter



d = {'a': [1, 2, 3], 'b': [3, 4, 5], 'c': [1, 1, 2]}

print(sorted(d.values(), key=itemgetter(1)))

# Вывод: [[1, 1, 2], [1, 2, 3], [3, 4, 5]]

5. attrgetter

operator.attrgetter(attr)
operator.attrgetter(*attrs)

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

Пример: сортировка списка объекта классов с помощью attrgetter. Функция attrgetter может получить атрибут объекта, а функция sorted будет выполнять сортировку на основе этого атрибута.

from operator import attrgetter



class Student:

    def __init__(self, name, rollno, grade):

        self.name = name

        self.rollno = rollno

        self.grade = grade



    def __repr__(self):

        return f"{self.name}-{self.rollno}-{self.grade}"



# Создание объектов

s1 = Student("Paul", 15, "second")

s2 = Student("Alex", 12, "fifth")

s3 = Student("Eva", 21, "first")

s4 = [s1, s2, s3]



# Сортировка списка объектов по атрибуту: rollno

s5 = sorted(s4, key=attrgetter('rollno'))

print(s5)

# Вывод: [Alex-12-fifth, Paul-15-second, Eva-21-first]

Многоуровневая сортировка

• С помощью itemgetter можно также выполнять сортировку на нескольких уровнях.

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

from operator import itemgetter



d = {'a': [1, 2, 9], 'b': [3, 2, 5], 'c': [1, 1, 2]}



# Сортировка по второму, затем по третьему элементу

print(sorted(d.values(), key=itemgetter(1, 2)))

# Вывод: [[1, 1, 2], [3, 2, 5], [1, 2, 9]]

• Многоуровневая сортировка с помощью лямбда-функции в key.

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

l1 = [(1, 2, 3), (4, 2, 0), (2, 1, 7)]

# Сортировка по второму элементу

# Если второй элемент равен, сортировка по третьему элементу.

print(sorted(l1, key=lambda x: x[1:3]))

Сортировка смешанных типов данных

Функция sorted не поддерживает смешанные типы данных. При попытке выполнить сортировку она вернет ошибку TypeError.

# список, содержащий смешанные типы данных

l1 = [1, 'a', 2]

print(sorted(l1))

# Вывод: TypeError: '>' not supported between instances of 'str' and 'int'

Выводы

1. При сортировке списка объектов класса параметр key является обязательным. Если его не указать, то вернется ошибка TypeError.
2. Для сортировки списка объектов класса можно использовать в качестве параметра key определенную пользователем функцию, лямбда-функцию или attrgetter.
3. Функция sorted() возвращает список.
4. Метода sort отсортирует сам оригинальный список. Но функция sorted возвращает новый список, не изменяя оригинальный.
5. Метод sort используется только для сортировки списка. Его нельзя использовать для строки, кортежа или словаря.

1. Введение

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

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

def function_name(args):
    '''docstring'''
    statements(s)

Синтаксис функций очень простой. Она начинается с ключевого слова def. Дальше идет уникальное имя, параметры и двоеточие. Также может быть документация (docstring), которая описывает назначение функции.

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

def basic_function(a):

    '''Базовая функция'''

    print('Базовая функция:', a)

    return a + 1



print('старт программы')

print('имя:', basic_function.__name__)

print('док:', basic_function.__doc__)

b = basic_function(1)

print('конец программы:', b)

Вывод:

старт программы
имя: basic_function
док: Базовая функция
Базовая функция: 1
конец программы: 2

Функция — это вызываемый объект. Как можно догадаться, это подразумевает объект, который можно вызвать. Проверить эту особенность можно с помощью встроенной функции callable().

Декораторы

Итак, декоратор — это функция, которая принимает функцию, делает что-то и возвращает другую функцию.

def decorator(func):

    def wrapper():

        print('функция-оболочка')

        func()

    return wrapper



def basic():

    print('основная функция')



wrapped = decorator(basic)

print('старт программы')

basic()

wrapped()

print('конец программы')

Если запустить эту программу:

старт программы
основная функция
функция-оболочка
основная функция
конец программы

Разберемся с тем, что здесь произошло. Функция decorator — это, как можно понять по названию, декоратор. Она принимает в качестве параметра функцию func. Крайне оригинальные имена. Внутри функции объявляется другая под названием wrapper. Объявлять ее внутри необязательно, но так проще работать.

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

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

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

def decorator(func):

    '''Основная функция'''

    print('декоратор')

    def wrapper():

        print('-- до функции', func.__name__)

        func()

        print('-- после функции', func.__name__)

    return wrapper

@decorator

def wrapped():

    print('--- обернутая функция')

print('- старт программы...')

wrapped()

print('- конец программы')

Вывод:

декоратор
- старт программы...
-- до функции wrapped
--- обернутая функция
-- после функции wrapped
- конец программы

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

def decorator_1(func):

    print('декоратор 1')

    def wrapper():

        print('перед функцией')

        func()

    return wrapper



def decorator_2(func):

    print('декоратор 2')

    def wrapper():

        print('перед функцией')

        func()

    return wrapper



@decorator_1

@decorator_2

def basic_1():

    print('basic_1')



@decorator_1

def basic_2():

    print('basic_2')



print('>> старт')

basic_1()

basic_2()

print('>> конец')

Вывод:

декоратор 2
декоратор 1
декоратор 1
>> старт
перед функцией
перед функцией
basic_1
перед функцией
basic_2
>> конец

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

@decorator_1
@decorator_2
def wrapped():

Равен следующему:

a = decorator_1(decorator_2(wrapped))

Если декорированная функция возвращает значение, и его нужно сохранить, то нужно сделать так, чтобы его возвращала и функция-обертка.

Декоратор-класс

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

Лучше всего разобрать это на примере.

class Decorator:

    def __init__(self, func):

        print('> Класс Decorator метод __init__')

        self.func = func



    def __call__(self):

        print('> перед вызовом класса...', self.func.__name__)

        self.func()

        print('> после вызова класса')



@Decorator

def wrapped():

    print('функция wrapped')



print('>> старт')

wrapped()

print('>> конец')

Вывод:

> Класс Decorator метод __init__
>> старт
> перед вызовом класса... wrapped
функция wrapped
> после вызова класса
>> конец

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

При вызове декорируемой функции на самом деле вызывается экземпляр класса. А поскольку объект вызываемый, то вызывается функция __call__.

Функция с аргументами

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

def decorator_with_args(func):

    print('> декоратор с аргументами...')

    def decorated(a, b):

        print('до вызова функции', func.__name__)

        ret = func(a, b)

        print('после вызова функции', func.__name__)

        return ret

    return decorated



@decorator_with_args

def add(a, b):

    print('функция 1')

    return a + b



@decorator_with_args

def sub(a, b):

    print('функция 2')

    return a - b



print('>> старт')

r = add(10, 5)

print('r:', r)

g = sub(10, 5)

print('g:', g)

print('>> конец')

Вывод:

> декоратор с аргументами...
> декоратор с аргументами...
>> старт
до вызова функции add
функция 1
после вызова функции add
r: 15
до вызова функции sub
функция 2
после вызова функции sub
g: 5
>> конец

А в случае с классом? Тот же принцип. Нужно лишь добавить желаемую сигнатуру в функцию __call__.

class Decorator:

    def __init__(self, func):

        print('> Класс Decorator метод __init__')

        self.func = func



    def __call__(self, a, b):

        print('> до вызова из класса...', self.func.__name__)

        self.func(a, b)

        print('> после вызова из класса')



@Decorator

def wrapped(a, b):

    print('функция wrapped:', a, b)



print('>> старт')

wrapped(10, 20)

print('>> конец')

Вывод:

> Класс Decorator метод __init__
>> старт
> до вызова из класса... wrapped
функция wrapped: 10 20
> после вызова из класса
>> конец

Можно использовать *args и **kwargs и для функции wrapper, если сигнатура заранее неизвестна, или будут приниматься разные типы функций.

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

В декоратор можно передать и сам параметр. В этом случае нужно добавить еще один слой абстракции, то есть — еще одну функцию-обертку.

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

def decorator_with_args(name):

    print('> decorator_with_args:', name)

    def real_decorator(func):

        print('>> сам декоратор', func.__name__)

        def decorated(*args, **kwargs):

            print('>>> перед функцие', func.__name__)

            ret = func(*args, **kwargs)

            print('>>> после функции', func.__name__)

            return ret

        return decorated

    return real_decorator



@decorator_with_args('test')

def add(a, b):

    print('>>>> функция add')

    return a + b



print('старт программы')

r = add(10, 10)

print(r)

print('конец программы')

Вывод:

> decorator_with_args: test
>> сам декоратор add
старт программы
>>> перед функцие add
>>>> функция add
>>> после функции add
20
конец программы

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

class DecoratorArgs:

    def __init__(self, name):

        print('> Декоратор с аргументами __init__:', name)

        self.name = name



    def __call__(self, func):

        def wrapper(a, b):

            print('>>> до обернутой функции')

            func(a, b)

            print('>>> после обернутой функции')

        return wrapper



@DecoratorArgs("teste")

def add(a, b):

    print('функция add:', a, b)



print('>> старт')

add(10, 20)

print('>> конец')

Вывод:

> Декоратор с аргументами __init__: teste
>> старт
>>> до обернутой функции
функция add: 10 20
>>> после обернутой функции
>> конец

Документация

Один из атрибутов функции — строка документации (docstring), доступ к которой можно получить с помощью __doc__. Это строковая константа, определяемая как первая инструкция в объявлении функции.

При декорации возвращается новая функция с другими атрибутами. Но они не изменяются.

def decorator(func):

    '''Декоратор'''

    def decorated():

        '''Функция Decorated'''

        func()

    return decorated



@decorator

def wrapped():

    '''Оборачиваемая функция'''

    print('функция wrapped')



print('старт программы...')

print(wrapped.__name__)

print(wrapped.__doc__)

print('конец программы')

В этом примере функция wrapped — это, по сути, функция decorated, которую она заменяет.

старт программы...
decorated
Функция Decorated
конец программы

Вот где на помощь приходит функция wraps из модуля functools. Она сохраняет атрибуты оригинальной функции. Нужно лишь декорировать функцию wrapper с ее помощью.

from functools import wraps



def decorator(func):

    '''Декоратор'''

    @wraps(func)

    def decorated():

        '''Функция Decorated'''

        func()

    return decorated



@decorator

def wrapped():

    '''Оборачиваемая функция'''

    print('функция wrapped')



print('старт программы...')

print(wrapped.__name__)

print(wrapped.__doc__)

print('конец программы')

Вывод:

старт программы...
wrapped
Оборачиваемая функция
конец программы

Приложения

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

Таймеры

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

from datetime import datetime

import time



def elapsed(func):

    def wrapper(a, b, delay=0):

        start = datetime.now()

        func(a, b, delay)

        end = datetime.now()

        elapsed = (end - start).total_seconds() * 1000

        print(f'>> функция {func.__name__} время выполнения (ms): {elapsed}')

    return wrapper



@elapsed

def add_with_delay(a, b, delay=0):

    print('сложить', a, b, delay)

    time.sleep(delay)

    return a + b



print('старт программы')

add_with_delay(10, 20)

add_with_delay(10, 20, 1)

print('конец программы')

Вывод:

старт программы
сложить 10 20 0
>> функция add_with_delay время выполнения (ms): 36.006
сложить 10 20 1
>> функция add_with_delay время выполнения (ms): 1031.255
конец программы

Логи

Еще один распространенный сценарий применения для декоратора — логирование функций.

import logging



def logger(func):

    log = logging.getLogger(__name__)

    def wrapper(a, b):

        log.info("Вызов функции ", func.__name__)

        ret = func(a, b)

        log.info("Вызвана функция ", func.__name__)

        return ret

    return wrapper



@logger

def add(a, b):

    print('a + b:', a + b)

    return a + b



print('>> старт')

add(10, 20)

add(20, 30)

print('>> конец')

Функция обратного вызова

Функция обратного вызова — это функция, которая вызывается при срабатывании определенного события (переходе на страницу, получении сообщения или окончании обработки процессором).

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

app = {}



def callback(route):

    def wrapper(func):

        app[route] = func

        def wrapped():

            ret = func()

            return ret

        return wrapped

    return wrapper



@callback('/')

def index():

    print('index')

    return 'OK'



print('> старт')

route = app.get('/')

if route:

    resp = route()

    print('ответ:', resp)



print('> конец')

Проверка состояний

Декораторы можно использовать для проверки состояния перед выполнение функции: например, зарегистрирован ли пользователь, есть ли у него достаточное количество прав или валидны ли аргументы (типы, значения и так далее).

user_permissions = ["user"]



def check_permission(permission):

    def wrapper_permission(func):

        def wrapped_check():

            if permission not in user_permissions:

                raise ValueError("Недостаточно прав")

            return func()

        return wrapped_check

    return wrapper_permission



@check_permission("user")

def check_value():

    return "значение"



@check_permission("admin")

def do_something():

    return "только админ"



print('старт программы')

check_value()

do_something()

print('конец программы')

Вывод:

Traceback (most recent call last):
  File "C:\Programs\Python\Python38-32\test.py", line 22, in <module>
    do_something()
  File "C:\Programs\Python\Python38-32\test.py", line 7, in wrapped_check
    raise ValueError("Недостаточно прав")
ValueError: Недостаточно прав

Создание singleton

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

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

def singleton(cls):

    '''Класс Singleton (один экземпляр)'''

    def wrapper_singleton(*args, **kwargs):

        if not wrapper_singleton.instance:

            wrapper_singleton.instance = cls(*args, **kwargs)

        return wrapper_singleton.instance

    wrapper_singleton.instance = None

    return wrapper_singleton



@singleton

class TheOne:

    pass



print('старт')

first_one = TheOne()

second_one = TheOne()

print(id(first_one))

print(id(second_one))

print('конец')

Вывод:

старт
56909912
56909912
конец

Обработка ошибок

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

def error_handler(func):

    def wrapper(*args, **kwargs):

        ret = 0

        try:

            ret = func(*args, **kwargs)

        except:

            print('>> Ошибка в функции', func.__name__)

        return ret

    return wrapper



@error_handler

def div(a, b):

    return a / b



print('старт')

print(div(10, 2))

print(div(10, 0))

print('конец')

Вывод:

старт
5.0
>> Ошибка в функции div
0
конец

Выводы

В этом материале была разобрана тема декораторов в Python. Это удобный инструмент, который улучшает код тем, что делает его проще и гибче.

Вот некоторые из особенностей декораторов:

• Их можно использовать повторно.
• Они могут получать параметры и возвращать значения.
• Могут хранить значения/
• Могут декорировать классы.
• Они могут добавлять функциональность в другие функции или классы.

В Python есть встроенные декораторы: classmethod, property и staticmethod.

Декораторы можно использовать и с другими методами (например, «магическими»), чтобы расширить возможности классов и всего проекта.

В этом материале рассмотрим 7 способов запуска кода, написанного на Python. Они будут работать вне зависимости от операционной системы, среды Python или местоположения кода.

Где запускать Python-скрипты и как?

Python-код можно запустить одним из следующих способов:

1. С помощью командной строки операционной системы (shell или терминал);
2. С помощью конкретной версии Python или Anaconda;
3. Использовать Crontab;
4. Запустить код с помощью другого Python-скрипта;
5. С помощью файлового менеджера;
6. Использовать интерактивный режим Python;
7. Использовать IDE или редактор кода.

Запуск Python-кода интерактивно

Для запуска интерактивной сессии нужно просто открыть терминал или командную строку и ввести python (или python3 в зависимости от версии). После нажатия Enter запустится интерактивный режим.

Вот как запустить интерактивный режим в разных ОС.

Интерактивный режим в Linux

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

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

Интерактивный режим в macOS

На устройствах с macOS все работает похожим образом. Изображение ниже демонстрирует интерактивный режим в этой ОС.

Интерактивный режим в Windows

В Windows нужно открыть командную строку и ввести python. После нажатия Enter появится приблизительно следующее:

Запуск Python-скриптов в интерактивном режиме

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

Этот код должен выводить целые числа от 0 до 5. В данном случае вывод — все, что появилось после print(i).

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

>>> exit()

И нажать Enter. Вы вернетесь в терминал, из которого и начинали.

Есть и другие способы остановки работы с интерактивным режимом Python. В Linux нужно нажать Ctrl + D, а в Windows — Ctrl + Z + Enter.

Стоит отметить, что при использовании этого режима Python-скрипты не сохраняются в локальный файл.

Как выполняются Python-скрипты?

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

Первая строка (кода):
    Вторая = строка кода
    Третья строка > кода:
        Четвертая (строка == кода)
    Пятая строка кода

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

Но и это еще не все.

Блок-схема выполнения кода интерпретатором

• Шаг 1: скрипт или .py-файл компилируется, и из него генерируются бинарные данные. Готовый файл имеет расширение .pyc или .pyo.
• Шаг 2: генерируется бинарный файл. Он читается интерпретатором для выполнения инструкций.

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

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

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

Как запускать Python-скрипты?

Для запуска Python-скрипта с помощью командной строки сначала нужно сохранить код в локальный файл.

Возьмем в качестве примера файл, который был сохранен как python_script.py. Сохранить его можно вот так:

• Создать Python-скрипт из командной строки и сохранить его,
• Создать Python-скрипт с помощью текстового редактора или IDE и сохранить его. Просто создайте файл, добавьте код и сохраните как «python_script.py»

Сохранить скрипт в текстовом редакторе достаточно легко. Процесс ничем не отличается от сохранения простого текстового файла.

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

sudo nano python_script.py

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

Теперь можно писать код и с легкостью сохранять его прямо в командной строке.

Как запускать скрипт в командной строке?

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

Замените python3 на python, если хотите использовать версию Python2.x.

Вот что будет храниться в самом файле python_script.py:

for i in range(0,5):

    print(i)

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

~$ python python_script.py
0
1
2
3
4

Предположим, что нужно сохранить вывод этого года (0, 1, 2, 3, 4). Для этого можно использовать оператор pipe.

Это делается вот так:

python python_script.py > newfile.txt

После этого будет создан файл «newfile.txt» с сохраненным выводом.

Как выполнять код интерактивно

Есть больше 4 способов запустить Python-скрипт интерактивно. Рассмотрим их все подробно.

Использование import для запуска скриптов

Импорт модулей для загрузки скриптов и библиотек используется постоянно. Можно даже написать собственный скрипт (например code1.py) и импортировать его в другой файл без необходимости повторять то же самое.

Вот как нужно импортировать code1.py в новом скрипте.

>>> import code1

Но таким образом импортируется все содержимое файла code1.py. Это не проблема до тех пор, пока не появляется необходимость, в том, чтобы код был оптимизирован и быстро работал.

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

Вот как это обычно делается.

>>> from code1 import chart_code1

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

Использование importlib для запуска кода

import_module() из importlib позволяет импортировать и исполнять другие Python-скрипты.

Это работает очень просто. Для скрипта code1.py нужно сделать следующее:

import importlib



import.import_module('code1')

И нет необходимости добавлять .py в import_module().

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

level1
|
+– __init__.py
 – level2
 |
 +– __init__.py
  – level3.py

В таком случае, написав, например, importlib.import_module("level3"), вы получите ошибку. Это называется относительным импортом и работает за счет явного использования относительного пути.

Так, для запуска скрипта level3.py можно написать так:

importlib.import_module('.level3', 'level1.level')



# или так

importlib.import_module('level1.level2.level3')

Запуск кода с помощью runpy

Модуль runpy ищет и исполняет Python-скрипт без импорта. Он также легко используется, ведь достаточно просто вызывать имя модуля в run_module().

Вот как, например, выполнить code1.py с помощью runpy.

>>> import runpy

>>> runpy.run_module(mod_name="code1")

Запуск кода динамически

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

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

>>> print_the_string  = 'print("Выполнен динамический код")'

>>> exec(print_the_string)

Однако этот способ уже устарел. Он медленный и непредсказуемый, а Python предлагает массу других вариантов.

Запуск скриптов Python из текстового редактора

Для запуска кода с помощью текстового редактора можно использовать команду по умолчанию (run) или горячие клавиши (Function + F5 или просто F5 в зависимости от ОС).