Логические операторы

В Python доступны следующие логические операторы:

• and (и) – возвращает True, если оба операнда истинны, иначе возвращает False. Унарный оператор (Означает что внутри только один операнд.)
• or (или) – возвращает True, если хотя бы один из операндов истинен, иначе возвращает False.
• not (не) – возвращает True, если операнд ложен, иначе возвращает False.

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

x = True
y = False

print(x and y)  # False
print(x or y)   # True
print(not x)    # False

Оператор not чаще всего используется в условиях if

x = True
y = False

print(not x)    # False
print(not y)    # True

Если использовать not not, тогда мы сконвертируем в логическое значение (оценка ложности значений)

Операторы and и or, это операторы короткого замыкания

Операторы имеют 2 операнда

a = True
b = False
c = True

print(a and b or c)  # True
print(a or b and c)  # True

Оператор распаковки словаря

Оператор ** позволяет распаковывать словари.

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

button = {
	'width' : 200,
	'text' : 'Buy'
}

red_button = {
	**button,
	'color': 'red'
}

print(red_button)
#{'width': 200, 'text': 'Buy', 'color': 'red'}

Если сменить цвет несколько раз, останется тот цвет(атрибу) который указан в конце
button = {
	'width' : 200,
	'text' : 'Buy'
}

red_button = {
	**button,
	'color': 'red'
}

blu_red_button = {
	**red_button,
	'color': 'blue'
}

print(blu_red_button)
#{'width': 200, 'text': 'Buy', 'color': '**blue'**}

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

button = {
	'width' : 200,
	'text' : 'Buy'
}

red_button = {
	**button,
	'height': '560'
}

blu_red_button = {
	**red_button,
	**button
}

print(blu_red_button)
#{'width': 200, 'text': 'Buy', 'height': '560'}

Есть еще вариант объединения словарей через | (ровный слеш)

button = {
	'width' : 200,
	'text' : 'Buy'
}

red_button = {
	'height': '560'
}

blu_red_button = button | red_button

print(blu_red_button)
#{'width': 200, 'text': 'Buy', 'height': '560'}

Инструкция del

Инструкция del

Инструкция del в Python используется для удаления элементов из списка, словаря или переменных. Вот некоторые примеры использования:

Удаление элемента из списка:

numbers = [1, 2, 3, 4, 5]
del numbers[2]
print(numbers)  # [1, 2, 4, 5]

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

person = {'name': 'John', 'age': 30, 'city': 'New York'}
del person['age']
print(person)  # {'name': 'John', 'city': 'New York'}

Удаление переменной:

x = 10
del x
print(x)  # NameError: name 'x' is not defined

Инструкция del также может использоваться для удаления срезов (частей) списка:

numbers = [1, 2, 3, 4, 5]
del numbers[1:3]
print(numbers)  # [1, 4, 5]

Инструкция del является мощным инструментом для управления данными в Python и может быть полезной при очистке памяти или удалении ненужных элементов.

Соединение строк

Метод join()

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

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

fruits = ['apple', 'banana', 'orange']
result = ', '.join(fruits)
print(result)  # 'apple, banana, orange'

В приведенном примере, метод join() используется для объединения строк из списка fruits. Разделитель, в данном случае запятая с пробелом ', ', указывается внутри метода join(). Результатом будет новая строка 'apple, banana, orange', в которой элементы списка fruits объединены с указанным разделителем.

Метод join() также может использоваться для объединения строк без указания разделителя. В этом случае, метод join() просто объединяет строки в одну строку без добавления дополнительных символов.

words = ['Hello', 'world']
result = ''.join(words)
print(result)  # 'Helloworld'

В этом примере, метод join() используется для объединения строк из списка words. Поскольку не указан разделитель, элементы списка объединяются непосредственно друг с другом, и результатом будет новая строка 'Helloworld'.

Метод join() является удобным инструментом для объединения строк из списка или кортежа в одну строку с помощью указанного разделителя.

Форматирование строк

Форматирование строк с использованием f-строк является еще одним полезным функционалом в Python. F-строки позволяют вставлять значения переменных непосредственно в строку с помощью фигурных скобок {} и префикса f перед строкой. Это позволяет создавать динамические строки, в которых значения будут заменяться на актуальные значения переменных.

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

name = "Alice"
age = 25

message = f"My name is {name} and I am {age} years old."
print(message)  # "My name is Alice and I am 25 years old."

В данном примере, переменные name и age вставляются в строку с помощью фигурных скобок. Значения переменных будут автоматически подставлены в соответствующие места в строке при выполнении программы.

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

x = 10
y = 5

result = f"The sum of {x} and {y} is {x + y}."
print(result)  # "The sum of 10 and 5 is 15."

В этом примере, выражение x + y вычисляется внутри фигурных скобок и результат подставляется в соответствующее место в строке.

Использование f-строк является удобным и эффективным способом форматирования строк в Python.

my_name = 'Aleksey'
my_hobby = 'running'
time = 8

info = my_name + ' likes ' + my_hobby + ' at ' + str(time) + ' o clock'
info2 = f"{my_name} likes {my_hobby} at {str(time)} o clock"

print(info)
print(info2)

#Aleksey likes running at 8 o clock
#Aleksey likes running at 8 o clock

В f строках можно не конвертировать информацию в строке. Так как f строки сами конвертируют данные

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

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

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

# Обычное определение функции
def square(x):
    return x ** 2

# Использование лямбда функции
square_lambda = lambda x: x ** 2

print(square(5))          # 25
print(square_lambda(5))   # 25

В этом примере определена функция square с использованием ключевого слова def, которая возвращает квадрат числа x. Также определена лямбда функция square_lambda, которая делает то же самое. Оба варианта возвращают результат 25 при вызове с аргументом 5.

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

# Лямбда функция с двумя аргументами
addition = lambda x, y: x + y

print(addition(3, 5))   # 8

В этом примере определена лямбда функция addition, которая принимает два аргумента x и y и возвращает их сумму.

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

# Пример использования лямбда функции в качестве аргумента
numbers = [1, 2, 3, 4, 5]

# Использование функции sorted с лямбда функцией в качестве ключа сортировки
sorted_numbers = sorted(numbers, key=lambda x: x % 2 == 0)

print(sorted_numbers)   # [1, 3, 5, 2, 4]

В этом примере функция sorted используется для сортировки списка numbers, а в качестве ключа сортировки используется лямбда функция, которая возвращает True, если число x является четным.

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

Обработка ошибок

В программировании ошибки могут возникать во время выполнения программы. Хорошим программистом является тот, кто предусматривает возможность возникновения ошибок и обрабатывает их правильно. В Python для обработки ошибок используется конструкция try-except.

Конструкция try-except позволяет программе перехватывать и обрабатывать исключения (ошибки), которые могут возникнуть в блоке кода, помещенном внутри try. Если в блоке try происходит исключение, то программа переходит к блоку except, где можно указать код для обработки этого исключения.

Пример использования конструкции try-except:

try:
    # Блок кода, в котором возможно возникновение исключения
    x = 10 / 0
except ZeroDivisionError:
    # Блок кода для обработки исключения ZeroDivisionError
    print("Ошибка деления на ноль")

В этом примере блок кода внутри try делит число 10 на ноль, что приводит к возникновению исключения ZeroDivisionError. Однако блок except ZeroDivisionError перехватывает это исключение и выводит сообщение о ошибке.

Конструкция try-except может иметь несколько блоков except, каждый из которых обрабатывает определенный тип исключения. Также можно указать блок else, который будет выполняться, если исключение не возникло.

try:
    # Блок кода, в котором возможно возникновение исключения
    x = int(input("Введите число: "))
    result = 10 / x
except ZeroDivisionError:
    # Блок кода для обработки исключения ZeroDivisionError
    print("Ошибка деления на ноль")
except ValueError:
    # Блок кода для обработки исключения ValueError
    print("Ошибка ввода числа")
else:
    # Блок кода, который выполняется, если исключение не возникло
    print("Результат:", result)

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

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

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

• SyntaxError (Синтаксическая ошибка): Происходит, когда в коде обнаруживается синтаксическая ошибка, такая как неправильное использование ключевых слов, отсутствие двоеточия или неправильное расположение операторов.
• NameError (Ошибка имени): Возникает, когда используется неопределенное имя или переменная.
• TypeError (Ошибка типа): Происходит, когда операция применяется к объекту неправильного типа, или когда функция вызывается с неправильным количеством аргументов или аргументами неправильного типа.
• ZeroDivisionError (Ошибка деления на ноль): Возникает, когда в программе происходит попытка деления на ноль.
• ValueError (Ошибка значения): Происходит, когда функция принимает аргумент правильного типа, но неправильного значения.
• IndexError (Ошибка индекса): Возникает, когда индекс выходит за границы допустимого диапазона или список пуст.
• FileNotFoundError (Ошибка файла не найден): Происходит, когда программа пытается открыть файл, который не существует.
• AttributeError (Ошибка атрибута): Возникает, когда объект не имеет определенного атрибута или метода.

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

Проверка на ошибки инпута:

def greeting(greet):
    return lambda name: f"{greet} {name}"
def get_valid_input():
    while True:
        try:
            info_text = input("Введите ваше имя: ")
            # Проверяем, что введенная строка состоит из букв и не пуста
            if info_text.isalpha():
                return info_text
            else:
                print("Пожалуйста, введите корректное имя (буквы без пробелов).")
        except ValueError:
            print("Пожалуйста, введите корректное значение.")

info_text = get_valid_input()

morning_greeting = greeting('Привет мир')
evening_greeting = greeting('Как дела?')

print(f"{morning_greeting(info_text)} {evening_greeting(info_text)}")

Получение информации об ошибке

Как получать текст из возникшей ошибке

Для получения текста из возникшей ошибки в Python, можно использовать блок try-except и метод str() для преобразования объекта ошибки в строку.

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

try:
    # Код, в котором возможно возникновение ошибки
    x = 10 / 0
except ZeroDivisionError as error:
    # Блок кода для обработки ошибки ZeroDivisionError
    error_message = str(error)
    print("Ошибка деления на ноль:", error_message)

В этом примере блок кода внутри try делит число 10 на ноль, что приводит к возникновению ошибки ZeroDivisionError. В блоке except ZeroDivisionError мы можем получить текст ошибки, преобразовав объект ошибки в строку с помощью str(error). Затем мы выводим сообщение об ошибке с полученным текстом.

Таким образом, используя блок try-except и метод str(), можно получить информацию об ошибке и вывести ее для дальнейшего анализа или обработки.

Создание ошибок с помощью raise

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

Пример создания ошибки с помощью raise:

def divide_numbers(a, b):
    if b == 0:
        raise ZeroDivisionError("Деление на ноль недопустимо.")
    return a / b

try:
    result = divide_numbers(10, 0)
    print(result)
except ZeroDivisionError as error:
    print("Произошла ошибка:", error)

В этом примере функция divide_numbers делит число a на число b. Если b равно нулю, мы вызываем raise ZeroDivisionError("Деление на ноль недопустимо."), чтобы создать новый экземпляр ошибки ZeroDivisionError и выбросить его. В блоке except ZeroDivisionError мы перехватываем эту ошибку и выводим соответствующее сообщение.

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

Условные инструкции

Условные инструкции

Условные инструкции в Python позволяют программе принимать решения и выполнять различные действия в зависимости от условий.

Инструкция if

Инструкция if используется для выполнения блока кода, если определенное условие истинно.

x = 10

if x > 5:
    print("x больше 5")

В этом примере, если значение переменной x больше 5, будет выполнена инструкция print(), которая выведет сообщение “x больше 5”.

Инструкция if-else

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

x = 10

if x > 5:
    print("x больше 5")
else:
    print("x меньше или равно 5")

В этом примере, если значение переменной x больше 5, будет выполнена инструкция print(), которая выведет сообщение “x больше 5”. В противном случае, если значение x меньше или равно 5, будет выполнена инструкция print(), которая выведет сообщение “x меньше или равно 5”.

Инструкция if-elif-else

Инструкция if-elif-else используется для выполнения различных блоков кода в зависимости от нескольких условий.

x = 10

if x > 5:
    print("x больше 5")
elif x < 5:
    print("x меньше 5")
else:
    print("x равно 5")

В этом примере, если значение переменной x больше 5, будет выполнена инструкция print(), которая выведет сообщение “x больше 5”. Если значение x меньше 5, будет выполнена инструкция print(), которая выведет сообщение “x меньше 5”. Если значение x равно 5, будет выполнена инструкция print(), которая выведет сообщение “x равно 5”.

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