Информация о Python

Переменные

Числовые переменные

Целые числа

int_var = 42

print(int_var)

Переменная int_var содержит целое число.

Строковые переменные

str_var = "Hello, World!"

print(str_var)

Переменная str_var содержит текстовую строку.

Логические переменные

Булевы переменные

bool_var = True

print(bool_var)

Переменная bool_var содержит логическое значение истина (True).

Нулевые переменные

none_var = None

print(none_var)

Переменная none_var не содержит значения (None).

Списковые переменные

list_var = [1, 2, 3]

print(list_var)

Переменная list_var содержит список упорядоченных элементов.

Кортежи

tuple_var = (1, 2, 3)

print(tuple_var)

Переменная tuple_var содержит кортеж неизменяемых элементов.

Словари

dict_var = {"имя": "Анна", "возраст": 25}

print(dict_var)

Переменная dict_var содержит словарь с парами ключ-значение.

Множества

set_var = {1, 2, 3}

print(set_var)

Переменная set_var содержит множество уникальных элементов.

Преобразование типов

Преобразование в целые числа (integer)

float_num = 3.14
            int_num = int(float_num)
            print(int_num)  # Выведет 3

В этом примере переменная `float_num` содержит число с плавающей запятой (float), и она преобразуется в целое число (integer) с использованием функции `int()`. Результат преобразования выводится на экран.

Преобразование в числа с плавающей запятой (float)

int_num = 42
            float_num = float(int_num)
            print(float_num)  # Выведет 42.0

В этом примере переменная `int_num` содержит целое число (integer), и она преобразуется в число с плавающей запятой (float) с использованием функции `float()`. Результат преобразования выводится на экран.

Преобразование в строки (string)

num = 123
            str_num = str(num)
            print("Число в виде строки: " + str_num)

В этом примере переменная `num` содержит число, и она преобразуется в строку (string) с использованием функции `str()`. Результат преобразования выводится вместе с текстом на экран.

Преобразование в логические значения (bool)

zero = 0
            non_zero = 42
            bool_zero = bool(zero)
            bool_non_zero = bool(non_zero)
            print("Нулевое значение как логическое: " + str(bool_zero))
            print("Ненулевое значение как логическое: " + str(bool_non_zero))

В этом примере переменные `zero` и `non_zero` содержат числа. Они преобразуются в логические значения (bool) с использованием функции `bool()`. Результат преобразования выводится вместе с текстом на экран.

Консольный ввод и вывод

Консольный ввод

В Python можно использовать функцию input() для чтения данных с консоли:

user_input = input("Введите что-то: ")
        print("Вы ввели:", user_input)

Программа запросит вас ввести данные, и затем выведет их на консоль.

Консольный вывод

Для вывода данных на консоль используется функция print():

print("Привет, мир!")

Этот код выведет "Привет, мир!" на консоль.

Примеры вывода в консоль

Простой вывод

print("Привет, мир!")

Этот код выведет "Привет, мир!" в консоль.

Форматированный вывод

name = "Миша"
                                age = 30
                                print(f"Привет, меня зовут {name} и мне {age} лет.")

Этот код использует форматированную строку для вывода имени и возраста в консоль. Он выведет "Привет, меня зовут Миша и мне 30 лет."

Вывод чисел и вычисления

a = 5
                                b = 10
                                sum = a + b
                                print(f"Сумма {a} и {b} равна {sum}.")

Этот код вычисляет сумму двух чисел и выводит результат в консоль. Он выведет "Сумма 5 и 10 равна 15."

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

Локальная область видимости

def my_function():
                local_var = 10  # Переменная local_var видна только внутри функции
                print(local_var)
            
            my_function()
            # print(local_var)  # Эта строка вызовет ошибку, так как local_var не видна за пределами функции

Переменная `local_var` создана внутри функции `my_function()`, и ее область видимости ограничена этой функцией. Она недоступна за пределами функции.

Глобальная область видимости

global_var = 20  # Переменная global_var видна в любом месте программы
            def my_function():
                print(global_var)
            
            my_function()
            print(global_var)  # Переменная global_var доступна за пределами функции

Переменная `global_var` создана вне функции и поэтому доступна в любом месте программы.

Неявная локальная область видимости

var = 30
            def my_function():
                var = 50  # Новая переменная var создана внутри функции и перекрывает глобальную var
                print(var)
            
            my_function()
            print(var)  # Выведет 30, так как глобальная переменная var не изменилась

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

Арифметические операции с числами

Сложение двух чисел

result = 5 + 3
            print("Сумма: ", result)

Этот код сложит 5 и 3, результат (8) будет выведен в консоль.

Вычитание двух чисел

result = 10 - 3
            print("Разность: ", result)

Этот код вычтет 3 из 10, результат (7) будет выведен в консоль.

Умножение двух чисел

result = 4 * 6
            print("Произведение: ", result)

Этот код умножит 4 на 6, результат (24) будет выведен в консоль.

Деление двух чисел

result = 15 / 3
            print("Частное: ", result)

Этот код разделит 15 на 3, результат (5.0) будет выведен в консоль.

Целочисленное деление двух чисел

result = 17 // 3
            print("Целочисленное деление: ", result)

Этот код выполнит целочисленное деление 17 на 3, результат (5) будет выведен в консоль.

Возведение в степень

result = 2 ** 3
            print("2 в степени 3: ", result)

Этот код возведет 2 в степень 3, результат (8) будет выведен в консоль.

Получение остатка от деления

result = 17 % 3
            print("Остаток от деления 17 на 3: ", result)

Этот код вернет остаток от деления 17 на 3, результат (2) будет выведен в консоль.

Арифметические операции с присвоением

Операция += (Сложение с присвоением)

a = 5
            a += 3
            print(a)  # Выведет 8

Эта операция сложит значение переменной a (5) с 3 и присвоит результат обратно переменной a.

Операция -= (Вычитание с присвоением)

b = 10
            b -= 4
            print(b)  # Выведет 6

Эта операция вычтет 4 из значения переменной b (10) и присвоит результат обратно переменной b.

Операция *= (Умножение с присвоением)

c = 3
            c *= 2
            print(c)  # Выведет 6

Эта операция умножит значение переменной c (3) на 2 и присвоит результат обратно переменной c.

Операция /= (Деление с присвоением)

d = 20
            d /= 4
            print(d)  # Выведет 5.0

Эта операция разделит значение переменной d (20) на 4 и присвоит результат обратно переменной d.

Операция //= (Целочисленное деление с присвоением)

e = 25
            e //= 3
            print(e)  # Выведет 8

Эта операция выполнит целочисленное деление значения переменной e (25) на 3 и присвоит результат обратно переменной e.

Операция %= (Получение остатка от деления с присвоением)

f = 17
            f %= 3
            print(f)  # Выведет 2

Эта операция вернет остаток от деления значения переменной f (17) на 3 и присвоит результат обратно переменной f.

Операции сравнения

Операция == (Равно)

x = 5
            y = 5
            result = x == y
            print(result)  # Выведет True

Эта операция проверит, равны ли переменные x и y, и вернет True, если они равны, и False в противном случае.

Операция != (Не равно)

a = 10
            b = 5
            result = a != b
            print(result)  # Выведет True

Эта операция проверит, не равны ли переменные a и b, и вернет True, если они не равны, и False в противном случае.

Операция > (Больше чем)

m = 8
            n = 3
            result = m > n
            print(result)  # Выведет True

Эта операция проверит, больше ли переменная m, чем переменная n, и вернет True, если это правда, и False в противном случае.

Операция < (Меньше чем)

p = 4
            q = 7
            result = p < q
            print(result)  # Выведет True

Эта операция проверит, меньше ли переменная p, чем переменная q, и вернет True, если это правда, и False в противном случае.

Операция >= (Больше или равно)

c = 5
            d = 5
            result = c >= d
            print(result)  # Выведет True

Эта операция проверит, больше ли или равна переменная c переменной d, и вернет True, если это правда, и False в противном случае.

Операция <= (Меньше или равно)

e = 2
            f = 3
            result = e <= f
            print(result)  # Выведет True

Эта операция проверит, меньше ли или равна переменная e переменной f, и вернет True, если это правда, и False в противном случае.

Оператор in

Оператор in (Принадлежность элементу)

fruits = ["яблоко", "банан", "груша"]
            check_fruit = "яблоко"
            
            result = check_fruit in fruits
            print(result)  # Выведет True

Этот код проверит, принадлежит ли переменная `check_fruit` списку `fruits`. Вернет True, если элемент найден в списке, и False в противном случае.

Условная конструкция if

Условный оператор if (если)

x = 10
            
            if x > 0:
                print("Число положительное")
            elif x == 0:
                print("Число ноль")
            else:
                print("Число отрицательное")

Этот код проверяет значение переменной `x`. Если `x` больше нуля, он выведет "Число положительное". Если `x` равно нулю, он выведет "Число ноль". В противном случае он выведет "Число отрицательное".

Циклы

Цикл for (для каждого элемента в последовательности)

fruits = ["яблоко", "банан", "груша"]
            for fruit in fruits:
                print(fruit)

Этот код перебирает каждый элемент в списке `fruits` и выводит его на экран.

Цикл while (пока условие истинно)

count = 1
            while count <= 5:
                print(count)
                count += 1

Этот код будет выводить числа от 1 до 5, пока переменная `count` меньше или равна 5.

Операторы break и continue

for i in range(10):
                if i == 3:
                    continue
                if i == 8:
                    break
                print(i)

Этот код использует оператор `continue` для пропуска числа 3 и оператор `break` для завершения цикла, когда i достигает 8.

Функции

Определение и вызов функции

def greet(name):
                print("Привет, " + name + "!")
                
            greet("Миша")

Этот код определяет функцию `greet`, которая принимает аргумент `name` и выводит приветствие с использованием этого аргумента. Затем он вызывает функцию `greet` с аргументом "Миша".

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

def add(x, y):
                return x + y
            
            result = add(3, 5)
            print(result)  # Выведет 8

Этот код определяет функцию `add`, которая возвращает сумму двух аргументов `x` и `y`. Затем он вызывает функцию `add` с аргументами 3 и 5 и выводит результат (8).

Аргументы по умолчанию

def greet(name="Гость"):
                print("Привет, " + name + "!")
                
            greet()  # Выведет "Привет, Гость!"

Этот код определяет функцию `greet` с аргументом по умолчанию "Гость". Если аргумент не передан, он использует значение по умолчанию.

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

def calculate_sum(*args):
                total = 0
                for num in args:
                    total += num
                return total
            
            result = calculate_sum(1, 2, 3, 4)
            print(result)  # Выведет 10

Этот код определяет функцию `calculate_sum`, которая принимает любое количество аргументов и возвращает их сумму. Оператор `*args` позволяет передавать переменное количество аргументов.

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

Позиционные параметры

def greet(name, age):
                        print("Привет, " + name + "! Тебе " + str(age) + " лет.")
                        
                    greet("Миша", 30)

Этот код определяет функцию `greet`, которая принимает два позиционных параметра `name` и `age` и выводит приветствие с их использованием.

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

def greet(name, age):
                        print("Привет, " + name + "! Тебе " + str(age) + " лет.")
                        
                    greet(age=30, name="Миша")

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

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

def greet(name, age=18):
                        print("Привет, " + name + "! Тебе " + str(age) + " лет.")
                        
                    greet("Анна")  # Выведет "Привет, Анна! Тебе 18 лет."

В этой функции параметр `age` имеет значение по умолчанию 18. Если значение `age` не передано, оно будет автоматически 18.

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

def calculate_sum(*args):
                        total = 0
                        for num in args:
                            total += num
                        return total
                    
                    result = calculate_sum(1, 2, 3, 4)
                    print(result)  # Выведет 10

Этот код использует оператор `*args` для принятия произвольного количества параметров. Он суммирует все переданные числа и возвращает результат.

Оператор return и возвращение результата из функции

Оператор return

def add(x, y):
                        result = x + y
                        return result
                    
                    sum = add(3, 5)
                    print(sum)  # Выведет 8

Этот код определяет функцию `add`, которая возвращает сумму двух аргументов `x` и `y` с использованием оператора `return`. Затем он вызывает функцию `add` с аргументами 3 и 5 и выводит результат (8).

Возврат нескольких значений

def get_name_and_age():
                        name = "Миша"
                        age = 30
                        return name, age
                    
                    name, age = get_name_and_age()
                    print("Имя:", name)
                    print("Возраст:", age)

Этот код определяет функцию `get_name_and_age`, которая возвращает два значения: имя и возраст. Затем он вызывает функцию и распаковывает возвращенные значения в переменные `name` и `age`, которые затем выводятся на экран.

Функция как тип, параметр и результат другой функции

Функция как параметр

def square(x):
                        return x * x
                    
                    def cube(x):
                        return x * x * x
                    
                    def apply(func, x):
                        return func(x)
                    
                    result_square = apply(square, 3)
                    result_cube = apply(cube, 3)
                    print("Квадрат числа:", result_square)  # Выведет 9
                    print("Куб числа:", result_cube)  # Выведет 27

Этот код определяет две функции `square` и `cube`, затем функцию `apply`, которая принимает другую функцию и аргумент и вызывает переданную функцию с переданным аргументом.

Функция как результат другой функции

def get_power_function(exponent):
                        def power(x):
                            return x ** exponent
                        return power
                    
                    square = get_power_function(2)
                    cube = get_power_function(3)
                    print("Квадрат числа 2:", square(2))  # Выведет 4
                    print("Куб числа 2:", cube(2))  # Выведет 8

Этот код определяет функцию `get_power_function`, которая возвращает другую функцию. Затем он создает функции `square` и `cube`, которые являются результатом вызова `get_power_function` с разными аргументами.

Декораторы

Пример декоратора

# Определение функции декоратора
            def select(input_func):    
                def output_func():      # Определяем функцию, которая будет выполняться вместо оригинальной
                    print("*****************")  # Перед выводом оригинальной функции выводим всякую звездочки
                    input_func()                # Вызов оригинальной функции
                    print("*****************")  # После вывода оригинальной функции выводим всякую звездочки
                return output_func     # Возвращаем новую функцию
             
            # Определение оригинальной функции
            @select         # Применение декоратора select
            def hello():
                print("Hello METANIT.COM")
             
            # Вызов оригинальной функции
            hello()

В данном примере функция `select` является декоратором. Она принимает функцию в качестве параметра, создает новую функцию `output_func`, которая модифицирует поведение оригинальной функции `hello`. После применения декоратора, вызов `hello()` будет выполнять `output_func`, а не оригинальную функцию `hello`.

Передача параметров в декоратор

# Определение функции декоратора
            def check(input_func):    
                def output_func(*args):      # Через *args получаем значения параметров оригинальной функции
                    input_func(*args)                # Вызов оригинальной функции с передачей параметров
                return output_func     # Возвращаем новую функцию
             
            # Определение оригинальной функции
            @check
            def print_person(name, age):
                print(f"Name: {name}  Age: {age}")
             
            # Вызов оригинальной функции
            print_person("Tom", 38)

В этом примере декоратор `check` принимает функцию `input_func` и возвращает функцию `output_func`. `output_func` принимает параметры через `*args` и передает их в `input_func`. Таким образом, мы можем модифицировать или проверять параметры, которые передаются в функцию.

Изменение результата функции

# Определение функции декоратора
            def check(input_func):    
                def output_func(*args):
                    result = input_func(*args)   # Передаем функции значения для параметров и получаем результат
                    if result < 0:
                        result = 0   # Если результат функции меньше нуля, возвращаем 0
                    return result
                return output_func
             
            # Определение оригинальной функции
            @check
            def sum(a, b):
                return a + b
             
            # Вызов оригинальной функции
            result1 = sum(10, 20)
            print(result1)          # Выведет 30
             
            result2 = sum(10, -20)
            print(result2)          # Выведет 0

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

Работа со списками

Создание списка

my_list = [1, 2, 3, 4, 5]

В этом примере создается список `my_list`, содержащий числа от 1 до 5.

Обращение к элементам списка

print(my_list[0])  # Выведет 1
            print(my_list[2])  # Выведет 3

Список индексируется с 0. Таким образом, `my_list[0]` обращается к первому элементу списка.

Разложение списка

a, b, c, d, e = my_list
            print(a, b, c)  # Выведет 1 2 3

Список можно разложить в переменные, как в данном примере.

Перебор элементов

for item in my_list:
            print(item)

Этот цикл перебирает элементы списка и выводит каждый из них.

Сравнение списков

list1 = [1, 2, 3]
            list2 = [1, 2, 3]
            print(list1 == list2)  # Выведет True

Списки могут быть сравнены на равенство.

Получение части списка (срезы)

my_list = [1, 2, 3, 4, 5]
            subset = my_list[1:4]
            print(subset)  # Выведет [2, 3, 4]

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

Методы и функции по работе со списками

my_list = [1, 2, 3]
                length = len(my_list)  # Получение длины списка, в данном случае 3
                index = my_list.index(2)  # Получение индекса элемента, в данном случае 1
                my_list.append(4)  # Добавление элемента в конец списка
                my_list.remove(2)  # Удаление элемента из списка, в данном случае элемент с значением 2
                print(my_list)  # Выведет [1, 3, 4]

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

Минимальное и максимальное значения

my_list = [3, 1, 4, 2]
                min_value = min(my_list)  # Находит минимальное значение, в данном случае 1
                max_value = max(my_list)  # Находит максимальное значение, в данном случае 4
                print(min_value, max_value)

Функции `min()` и `max()` позволяют найти минимальное и максимальное значение в списке соответственно.

Соединение списков

list1 = [1, 2, 3]
                list2 = [4, 5, 6]
                combined_list = list1 + list2  # Соединяет два списка в один
                print(combined_list)  # Выведет [1, 2, 3, 4, 5, 6]

Используйте оператор `+` для соединения двух списков в один.

Списки списков

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
                print(matrix[1][1])  # Выведет 5, элемент во втором ряду и втором столбце

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

Изменение подсписка

my_list = [1, 2, 3, 4, 5]
                my_list[1:4] = [8, 9, 10]  # Заменяет подсписок [2, 3, 4] на [8, 9, 10]
                print(my_list)  # Выведет [1, 8, 9, 10, 5]

Используйте срезы и присваивание для замены подсписков в списке.

Подсчет вхождений

my_list = [1, 2, 2, 3, 2, 4, 2]
                count_2 = my_list.count(2)  # Подсчитывает количество вхождений числа 2 в списке
                print(count_2)  # Выведет 4

Метод `count()` используется для подсчета количества вхождений определенного элемента в список.

Удаление с помощью `remove`

my_list = [1, 2, 3, 4, 5]
                my_list.remove(3)  # Удаляет первое вхождение числа 3 из списка
                print(my_list)  # Выведет [1, 2, 4, 5]

Метод `remove()` удаляет первое вхождение определенного элемента в списке.

Удаление с помощью `del`

my_list = [1, 2, 3, 4, 5]
                del my_list[2]  # Удаляет элемент с индексом 2 из списка
                print(my_list)  # Выведет [1, 2, 4, 5]

Команда `del` позволяет удалить элемент из списка по его индексу.

Сортировка списка

my_list = [5, 2, 9, 1, 5]
                my_list.sort()  # Сортирует список по возрастанию
                print(my_list)  # Выведет [1, 2, 5, 5, 9]

Метод `sort()` сортирует список по возрастанию. Используйте `sort(reverse=True)` для сортировки по убыванию.

Соединение списков

list1 = [1, 2, 3]
                list2 = [4, 5, 6]
                merged_list = list1 + list2  # Соединяет два списка в один
                print(merged_list)  # Выведет [1, 2, 3, 4, 5, 6]

Используйте оператор `+` для соединения (конкатенации) двух списков.

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

my_list = list(range(1, 11))
                print(my_list)  # Выведет [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Функция `range(start, stop, step)` создает последовательность чисел от `start` до `stop-1` с интервалом `step` (по умолчанию 1).

Копирование списка

original_list = [1, 2, 3]
                copied_list = original_list.copy()  # Создает копию списка
                print(copied_list)  # Выведет [1, 2, 3]

Используйте метод `copy()` для создания независимой копии списка.

Обратный порядок элементов

my_list = [1, 2, 3, 4, 5]
                my_list.reverse()  # Обращает порядок элементов в списке
                print(my_list)  # Выведет [5, 4, 3, 2, 1]

Метод `reverse()` меняет порядок элементов в списке на противоположный.

Расширение списка

my_list = [1, 2, 3]
                my_list.extend([4, 5, 6])  # Расширяет список, добавляя элементы из другого списка
                print(my_list)  # Выведет [1, 2, 3, 4, 5, 6]

Метод `extend(iterable)` добавляет элементы из итерируемого объекта (например, списка или кортежа) в конец списка.

Использование списков в условиях

my_list = [1, 2, 3, 4, 5]
                if 3 in my_list:
                    print("Элемент 3 присутствует в списке")
                else:
                    print("Элемент 3 отсутствует в списке")

Оператор `in` позволяет проверить наличие элемента в списке. Он возвращает `True`, если элемент присутствует в списке, и `False` в противном случае.

Использование списков в циклах

my_list = [1, 2, 3, 4, 5]
                for item in my_list:
                    print(item)

Списки могут быть перебраны в циклах. Каждый элемент списка будет присвоен переменной `item` в примере выше.

Генераторы списков

squared_numbers = [x**2 for x in range(1, 6)]  # Генерация списка квадратов чисел от 1 до 5
                print(squared_numbers)  # Выведет [1, 4, 9, 16, 25]

Генераторы списков - это компактный способ создания списков в Python. Они позволяют вам создавать списки на основе выражений и циклов.

Использование метода `zip()`

names = ['Alice', 'Bob', 'Charlie']
                ages = [25, 30, 35]
                combined = list(zip(names, ages))  # Сопоставление имен и возрастов в кортежи и создание списка кортежей
                print(combined)  # Выведет [('Alice', 25), ('Bob', 30), ('Charlie', 35)]

Метод `zip()` позволяет объединить несколько списков в список кортежей, сопоставляя элементы с одинаковыми индексами.

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

my_list = [1, 2, 3, 4, 5]
                my_list[2] = 10
                print(my_list)  # Выведет [1, 2, 10, 4, 5]

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

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

my_list = [1, 2, 3, 4, 5]
                del my_list[2]
                print(my_list)  # Выведет [1, 2, 4, 5]

Команда `del` удаляет элемент из списка по его индексу.

Объединение списков

list1 = [1, 2, 3]
                list2 = [4, 5, 6]
                merged_list = list1 + list2
                print(merged_list)  # Выведет [1, 2, 3, 4, 5, 6]

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

Распаковка списков

numbers = [1, 2, 3]
                a, b, c = numbers
                print(a, b, c)  # Выведет 1 2 3

Список можно распаковать, присвоив его элементы переменным в одной строке кода.

Метод `extend()` для добавления элементов из другого списка

list1 = [1, 2, 3]
                list2 = [4, 5, 6]
                list1.extend(list2)
                print(list1)  # Выведет [1, 2, 3, 4, 5, 6]

Метод `extend()` добавляет элементы из одного списка в конец другого списка.

Метод `count()` для подсчета вхождений элемента в список

numbers = [1, 2, 2, 3, 2, 4]
                count_of_twos = numbers.count(2)
                print(count_of_twos)  # Выведет 3

Метод `count()` возвращает количество вхождений указанного элемента в список.

Метод `index()` для поиска индекса элемента в списке

numbers = [1, 2, 3, 4, 5]
                index_of_three = numbers.index(3)
                print(index_of_three)  # Выведет 2

Метод `index()` возвращает индекс первого вхождения указанного элемента в список.

Метод `reverse()` для изменения порядка элементов в списке

numbers = [1, 2, 3, 4, 5]
                numbers.reverse()
                print(numbers)  # Выведет [5, 4, 3, 2, 1]

Метод `reverse()` изменяет порядок элементов в списке на обратный.

Метод `sort()` для сортировки элементов в списке

numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
                numbers.sort()
                print(numbers)  # Выведет [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

Метод `sort()` сортирует элементы в списке в порядке возрастания. Можно использовать параметр `reverse=True` для сортировки в убывающем порядке.

Списковые выражения (List Comprehensions)

numbers = [1, 2, 3, 4, 5]
                squared_numbers = [x**2 for x in numbers]
                print(squared_numbers)  # Выведет [1, 4, 9, 16, 25]

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

Использование `map()` для применения функции к каждому элементу списка

numbers = [1, 2, 3, 4, 5]
                def square(x):
                    return x**2
                squared_numbers = list(map(square, numbers))
                print(squared_numbers)  # Выведет [1, 4, 9, 16, 25]

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

Использование `filter()` для фильтрации элементов в списке

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
                def is_even(x):
                    return x % 2 == 0
                even_numbers = list(filter(is_even, numbers))
                print(even_numbers)  # Выведет [2, 4, 6, 8, 10]

Функция `filter()` фильтрует элементы списка на основе условия, определенного в указанной функции.

Использование `reduce()` для свертки списка к одному значению

from functools import reduce
                numbers = [1, 2, 3, 4, 5]
                def multiply(x, y):
                    return x * y
                product = reduce(multiply, numbers)
                print(product)  # Выведет 120

Функция `reduce()` последовательно применяет указанную функцию к элементам списка, сворачивая список до одного значения.

Списковые методы и функции

numbers = [1, 2, 3, 4, 5]
                numbers.append(6)  # Добавляет элемент в конец списка
                print(numbers)  # Выведет [1, 2, 3, 4, 5, 6]
                
                numbers.remove(3)  # Удаляет первое вхождение указанного элемента
                print(numbers)  # Выведет [1, 2, 4, 5, 6]
                
                numbers.sort()  # Сортирует список по возрастанию
                print(numbers)  # Выведет [1, 2, 4, 5, 6]
                
                numbers.reverse()  # Разворачивает список в обратном порядке
                print(numbers)  # Выведет [6, 5, 4, 2, 1]
                
                print(len(numbers))  # Выведет длину списка, в данном случае 5

Списки в Python имеют множество встроенных методов и функций для удобной работы с данными.

Объединение списков

list1 = [1, 2, 3]
                list2 = [4, 5, 6]
                merged_list = list1 + list2  # Объединяет два списка в один
                print(merged_list)  # Выведет [1, 2, 3, 4, 5, 6]

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

Разделение списка

numbers = [1, 2, 3, 4, 5, 6]
                split_index = 3
                first_part = numbers[:split_index]  # Получает первую часть списка до указанного индекса (не включительно)
                second_part = numbers[split_index:]  # Получает вторую часть списка от указанного индекса (включительно)
                print(first_part)  # Выведет [1, 2, 3]
                print(second_part)  # Выведет [4, 5, 6]

Список можно разделить на две части, используя срезы (slices) с указанием индекса разделения.

Проверка наличия элемента

numbers = [1, 2, 3, 4, 5]
                element_to_check = 3
                if element_to_check in numbers:
                    print(f"{element_to_check} присутствует в списке.")
                else:
                    print(f"{element_to_check} отсутствует в списке.")

С помощью оператора `in` можно проверить, содержится ли определенный элемент в списке.

Изменение подсписка

numbers = [1, 2, 3, 4, 5]
                numbers[1:3] = [10, 20, 30]  # Заменяет подсписок на новые значения
                print(numbers)  # Выведет [1, 10, 20, 30, 4, 5]

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

Подсчет вхождений

numbers = [1, 2, 3, 2, 4, 2, 5]
                count = numbers.count(2)  # Подсчитывает количество вхождений указанного элемента в список
                print(count)  # Выведет 3, так как число 2 встречается три раза в списке

Метод `count()` позволяет подсчитать, сколько раз определенный элемент встречается в списке.

Соединение списков

list1 = [1, 2, 3]
                list2 = [4, 5, 6]
                merged_list = list1 + list2  # Соединяет два списка в один
                print(merged_list)  # Выведет [1, 2, 3, 4, 5, 6]

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

Кортеж

Создание кортежа

my_tuple = (1, 2, 3)
            print(my_tuple)  # Выведет (1, 2, 3)

Кортежи создаются с использованием круглых скобок `()`. Они являются неизменяемыми, то есть их нельзя изменить после создания.

Обращение к элементам кортежа

my_tuple = (1, 2, 3)
            print(my_tuple[1])  # Выведет 2

Элементы кортежа можно получить по их индексам, так же как и в списках.

Разложение кортежа

my_tuple = (1, 2, 3)
            a, b, c = my_tuple
            print(a)  # Выведет 1
            print(b)  # Выведет 2
            print(c)  # Выведет 3

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

Диапазон

Создание диапазона с помощью функции range()

range(stop): возвращает все целые числа от 0 до stop.
range(start, stop): возвращает все целые числа в промежутке от start (включая) до stop (не включая).
range(start, stop, step): возвращает целые числа в промежутке от start (включая) до stop (не включая), которые увеличиваются на значение step.

range_example1 = range(5)
            print(list(range_example1))  # Выведет [0, 1, 2, 3, 4]
                    
            range_example2 = range(2, 10)
            print(list(range_example2))  # Выведет [2, 3, 4, 5, 6, 7, 8, 9]
                    
            range_example3 = range(1, 20, 3)
            print(list(range_example3))  # Выведет [1, 4, 7, 10, 13, 16, 19]

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

Преобразование диапазона в список

my_range = range(3)
            my_list = list(my_range)
            print(my_list)  # Выведет [0, 1, 2]

Диапазон можно преобразовать в список с помощью функции `list()`.

Словари

Создание и обращение к словарям в Python

Словари в Python - это неупорядоченные коллекции, которые используются для хранения пар ключ-значение.

# Создание словаря
                        my_dict = {"name": "Alice", "age": 30, "city": "New York"}
                        
                        # Обращение к элементам словаря
                        print(my_dict["name"])  # Выведет "Alice"
                        print(my_dict["age"])   # Выведет 30

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

Изменение и добавление элементов в словарь

# Изменение значения по ключу
                        my_dict["age"] = 31
                        
                        # Добавление нового элемента в словарь
                        my_dict["job"] = "Developer"
                        
                        print(my_dict)

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

Методы словарей

# Вывод всех ключей
                        print(my_dict.keys())
                        
                        # Вывод всех значений
                        print(my_dict.values())
                        
                        # Проверка наличия ключа в словаре
                        print("name" in my_dict)  # Выведет True
                        
                        # Удаление элемента по ключу
                        del my_dict["job"]
                        
                        # Получение значения по ключу с предоставлением значения по умолчанию
                        print(my_dict.get("job", "Not Found"))  # Выведет "Not Found"

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

Итерация по словарям

# Итерация по ключам
                        for key in my_dict:
                            print(key, my_dict[key])
                        
                        # Итерация по парам ключ-значение
                        for key, value in my_dict.items():
                            print(key, value)

Вы можете итерироваться по ключам или парам ключ-значение в словаре, используя циклы.

Словари со сложными ключами

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

# Словарь с кортежами в качестве ключей
                        coordinate_dict = {(0, 1): "наверх", (0, -1): "вниз", (1, 0): "вправо", (-1, 0): "влево"}

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

Вложенные словари

# Вложенные словари
                        nested_dict = {
                            "person1": {"name": "Alice", "age": 30},
                            "person2": {"name": "Bob", "age": 25}
                        }

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

Удаление элементов из словаря

# Удаление элемента по ключу
                        del my_dict["key_name"]
                        
                        # Удаление элемента с возвратом значения
                        removed_value = my_dict.pop("key_name", None)

Элементы можно удалять из словаря по ключу. Метод `pop()` также возвращает удаленное значение или значение по умолчанию, если ключ не найден.

Проверка наличия ключа в словаре

# Проверка наличия ключа
                        if "key_name" in my_dict:
                            print("Ключ существует")

С помощью оператора `in` можно проверить, существует ли определенный ключ в словаре.

Копирование словаря

# Полное копирование словаря
                        copied_dict = my_dict.copy()
                        
                        # Копирование словаря с использованием dict()
                        copied_dict = dict(my_dict)

Для создания копии словаря используются метод `copy()` или функция `dict()`.

Объединение словарей

# Объединение словарей (Python 3.9+)
                        merged_dict = {**dict1, **dict2}
                        
                        # Объединение словарей с использованием метода update()
                        dict1.update(dict2)

Словари можно объединить в один новый словарь, используя оператор `**` (Python 3.9+) или метод `update()`.

Словари списков

# Создание словаря списков
                        dict_of_lists = {"key1": [1, 2, 3], "key2": [4, 5, 6]}
                        
                        # Добавление элемента в список в словаре
                        dict_of_lists["key1"].append(4)

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

Множества

Создание множества

# Создание множества
                            my_set = {1, 2, 3, 4, 5}

Множество можно создать, указав элементы в фигурных скобках.

Добавление элемента в множество

# Добавление элемента в множество
                            my_set.add(6)

Элемент можно добавить в множество с использованием метода `add()`.

Удаление элемента из множества

# Удаление элемента из множества
                            my_set.remove(3)

Элемент можно удалить из множества с использованием метода `remove()`.

Проверка наличия элемента в множестве

# Проверка наличия элемента в множестве
                            if 2 in my_set:
                                print("Элемент существует")

С использованием оператора `in` можно проверить, существует ли определенный элемент в множестве.

Операции с множествами

# Объединение множеств
                            union_set = set1.union(set2)
                            
                            # Пересечение множеств
                            intersection_set = set1.intersection(set2)
                            
                            # Разность множеств
                            difference_set = set1.difference(set2)

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

Методы и функции по работе с множествами

# Добавление множества к другому множеству
                            set1.update(set2)
                            
                            # Копирование множества
                            copied_set = set1.copy()

Множества поддерживают различные методы, такие как `update()` для добавления множества к другому множеству и `copy()` для создания копии множества.