40 задач для начинающих Python-разработчиков: от основ к практике

# Решение:
celsius = float(input("Введите температуру в градусах Цельсия: "))
fahrenheit = (celsius * 9/5) + 32
print(f"{celsius}°C = {fahrenheit}°F")

# Решение:
import math
radius = float(input("Введите радиус круга: "))
area = math.pi * (radius ** 2)
print(f"Площадь круга с радиусом {radius} = {area:.2f}")

# Решение:
price = float(input("Введите сумму без НДС: "))
vat = price * 0.2
total = price + vat
print(f"Сумма НДС: {vat:.2f}")
print(f"Итоговая сумма с НДС: {total:.2f}")

# Решение:
a = input("Введите значение a: ")
b = input("Введите значение b: ")

# Способ 1: с использованием временной переменной
temp = a
a = b
b = temp

# Способ 2: особенность Python
a, b = b, a

print(f"После обмена: a = {a}, b = {b}")

# Решение:
rate = float(input("Введите текущий курс доллара к рублю: "))
rubles = float(input("Введите сумму в рублях: "))
dollars = rubles / rate
print(f"{rubles} рублей = {dollars:.2f} долларов")

# Решение:
weight = float(input("Введите вес в килограммах: "))
height = float(input("Введите рост в метрах: "))
bmi = weight / (height ** 2)
print(f"Ваш индекс массы тела: {bmi:.2f}")

# Решение:
principal = float(input("Введите начальную сумму вклада: "))
rate = float(input("Введите годовую процентную ставку (%): ")) / 100
time = int(input("Введите срок вклада в годах: "))
interest = principal * rate * time
total = principal + interest
print(f"Накопленные проценты: {interest:.2f}")
print(f"Итоговая сумма: {total:.2f}")

# Решение:
bill = float(input("Введите сумму счета: "))
tip_percent = float(input("Введите процент чаевых (%): ")) / 100
people = int(input("Введите количество человек: "))
total = bill * (1 + tip_percent)
per_person = total / people
print(f"Каждый человек должен заплатить: {per_person:.2f}")

# Решение:
number = int(input("Введите число: "))
if number % 2 == 0:
print(f"{number} – четное число")
else:
print(f"{number} – нечетное число")

# Решение:
a = float(input("Введите первое число: "))
b = float(input("Введите второе число: "))
c = float(input("Введите третье число: "))

if a >= b and a >= c:
max_number = a
elif b >= a and b >= c:
max_number = b
else:
max_number = c

print(f"Наибольшее число: {max_number}")

# Решение:
num1 = float(input("Введите первое число: "))
num2 = float(input("Введите второе число: "))
operation = input("Выберите операцию (+, -, *, /): ")

if operation == "+":
result = num1 + num2
elif operation == "-":
result = num1 – num2
elif operation == "*":
result = num1 * num2
elif operation == "/":
if num2 != 0:
result = num1 / num2
else:
result = "Ошибка: деление на ноль"
else:
result = "Неизвестная операция"

print(f"Результат: {result}")

# Решение:
number = int(input("Введите число для таблицы умножения: "))

for i in range(1, 11):
print(f"{number} × {i} = {number * i}")

# Решение:
n = int(input("Введите число N: "))
sum_numbers = 0

for i in range(1, n + 1):
sum_numbers += i

print(f"Сумма чисел от 1 до {n}: {sum_numbers}")

# Решение:
n = int(input("Введите неотрицательное целое число: "))
factorial = 1

if n < 0:
print("Факториал определен только для неотрицательных чисел")
else:
for i in range(1, n + 1):
factorial *= i
print(f"{n}! = {factorial}")

# Решение:
n = int(input("Введите верхнюю границу диапазона: "))
print(f"Простые числа в диапазоне от 2 до {n}:")

for num in range(2, n + 1):
is_prime = True
for i in range(2, int(num ** 0.5) + 1):
if num % i == 0:
is_prime = False
break
if is_prime:
print(num, end=" ")

# Решение:
text = input("Введите строку: ").lower().replace(" ", "")
is_palindrome = True

for i in range(len(text) // 2):
if text[i] != text[len(text) – 1 – i]:
is_palindrome = False
break

if is_palindrome:
print("Это палиндром!")
else:
print("Это не палиндром.")

# Решение:
import random

secret_number = random.randint(1, 100)
attempts = 0
max_attempts = 7

print("Я загадал число от 1 до 100. У вас есть 7 попыток угадать его.")

while attempts < max_attempts:
guess = int(input("Ваш вариант: "))
attempts += 1

if guess < secret_number:
print("Загаданное число больше.")
elif guess > secret_number:
print("Загаданное число меньше.")
else:
print(f"Поздравляю! Вы угадали число {secret_number} за {attempts} попыток!")
break

if guess != secret_number:
print(f"Увы, попытки закончились. Загаданное число было: {secret_number}")

# Решение:
height = int(input("Введите высоту пирамиды: "))

for i in range(1, height + 1):
spaces = " " * (height – i)
stars = "*" * (2 * i – 1)
print(spaces + stars)

# Решение:
def greet_user(name):
"""Функция для приветствия пользователя по имени."""
print(f"Привет, {name}! Рад тебя видеть.")

# Пример использования
user_name = input("Введите ваше имя: ")
greet_user(user_name)

# Решение:
import math

def calculate_circle_area(radius):
"""Вычисляет площадь круга по радиусу."""
return math.pi * radius ** 2

def calculate_rectangle_area(length, width):
"""Вычисляет площадь прямоугольника по длине и ширине."""
return length * width

def calculate_triangle_area(a, b, c):
"""Вычисляет площадь треугольника по трем сторонам (формула Герона)."""
s = (a + b + c) / 2 # полупериметр
return math.sqrt(s * (s – a) * (s – b) * (s – c))

# Пример использования
print(f"Площадь круга с радиусом 5: {calculate_circle_area(5):.2f}")
print(f"Площадь прямоугольника 4×6: {calculate_rectangle_area(4, 6)}")
print(f"Площадь треугольника со сторонами 3, 4, 5: {calculate_triangle_area(3, 4, 5):.2f}")

# Решение:
def is_prime(number):
"""Проверяет, является ли число простым."""
if number <= 1:
return False
if number <= 3:
return True
if number % 2 == 0 or number % 3 == 0:
return False

i = 5
while i * i <= number:
if number % i == 0 or number % (i + 2) == 0:
return False
i += 6
return True

# Пример использования
num = int(input("Введите число для проверки: "))
if is_prime(num):
print(f"{num} – простое число")
else:
print(f"{num} – составное число")

# Решение:
def factorial(n):
"""Вычисляет факториал числа n с использованием рекурсии."""
if n == 0 or n == 1:
return 1
else:
return n * factorial(n – 1)

# Пример использования
num = int(input("Введите число для вычисления факториала: "))
if num < 0:
print("Факториал определен только для неотрицательных чисел")
else:
print(f"{num}! = {factorial(num)}")

# Решение:
def celsius_to_fahrenheit(celsius):
"""Конвертирует температуру из Цельсия в Фаренгейт."""
return (celsius * 9/5) + 32

def fahrenheit_to_celsius(fahrenheit):
"""Конвертирует температуру из Фаренгейта в Цельсий."""
return (fahrenheit – 32) * 5/9

def celsius_to_kelvin(celsius):
"""Конвертирует температуру из Цельсия в Кельвин."""
return celsius + 273.15

def kelvin_to_celsius(kelvin):
"""Конвертирует температуру из Кельвина в Цельсий."""
return kelvin – 273.15

# Пример использования
temp = float(input("Введите температуру: "))
unit = input("Введите единицу измерения (C, F, K): ").upper()

if unit == "C":
print(f"{temp}°C = {celsius_to_fahrenheit(temp):.2f}°F")
print(f"{temp}°C = {celsius_to_kelvin(temp):.2f}K")
elif unit == "F":
celsius = fahrenheit_to_celsius(temp)
print(f"{temp}°F = {celsius:.2f}°C")
print(f"{temp}°F = {celsius_to_kelvin(celsius):.2f}K")
elif unit == "K":
celsius = kelvin_to_celsius(temp)
print(f"{temp}K = {celsius:.2f}°C")
print(f"{temp}K = {celsius_to_fahrenheit(celsius):.2f}°F")
else:
print("Неизвестная единица измерения")

# Решение:
def gcd(a, b):
"""Находит наибольший общий делитель двух чисел по алгоритму Евклида."""
while b:
a, b = b, a % b
return a

# Пример использования
num1 = int(input("Введите первое число: "))
num2 = int(input("Введите второе число: "))
print(f"НОД({num1}, {num2}) = {gcd(num1, num2)}")

# Решение:
def fibonacci_sequence(limit):
"""Генерирует последовательность чисел Фибоначчи до заданного предела."""
sequence = [0, 1]

while True:
next_number = sequence[-1] + sequence[-2]
if next_number > limit:
break
sequence.append(next_number)

return sequence

# Пример использования
limit = int(input("Введите предел для последовательности Фибоначчи: "))
fib_sequence = fibonacci_sequence(limit)
print(f"Последовательность Фибоначчи до {limit}: {fib_sequence}")

# Решение:
def count_vowels(text):
"""Подсчитывает количество гласных букв в строке."""
vowels = "аеёиоуыэюяaeiou"
count = 0

for char in text.lower():
if char in vowels:
count += 1

return count

# Пример использования
text = input("Введите строку для подсчета гласных: ")
vowel_count = count_vowels(text)
print(f"В строке '{text}' содержится {vowel_count} гласных букв.")

# Решение:
def is_palindrome(text):
"""Проверяет, является ли строка палиндромом."""
# Удаляем пробелы и приводим к нижнему регистру
cleaned_text = ''.join(text.lower().split())

# Сравниваем строку с ее обратной версией
return cleaned_text == cleaned_text[::-1]

# Пример использования
text = input("Введите строку для проверки на палиндром: ")
if is_palindrome(text):
print(f"'{text}' – это палиндром!")
else:
print(f"'{text}' – это не палиндром.")

# Решение:
def add(x, y):
"""Сложение двух чисел."""
return x + y

def subtract(x, y):
"""Вычитание второго числа из первого."""
return x – y

def multiply(x, y):
"""Умножение двух чисел."""
return x * y

def divide(x, y):
"""Деление первого числа на второе."""
if y == 0:
return "Ошибка: деление на ноль"
return x / y

def power(x, y):
"""Возведение числа x в степень y."""
return x ** y

# Пример использования
print("Выберите операцию:")
print("1. Сложение")
print("2. Вычитание")
print("3. Умножение")
print("4. Деление")
print("5. Возведение в степень")

choice = input("Введите номер операции (1/2/3/4/5): ")

num1 = float(input("Введите первое число: "))
num2 = float(input("Введите второе число: "))

if choice == '1':
print(f"{num1} + {num2} = {add(num1, num2)}")
elif choice == '2':
print(f"{num1} – {num2} = {subtract(num1, num2)}")
elif choice == '3':
print(f"{num1} * {num2} = {multiply(num1, num2)}")
elif choice == '4':
print(f"{num1} / {num2} = {divide(num1, num2)}")
elif choice == '5':
print(f"{num1} ^ {num2} = {power(num1, num2)}")
else:
print("Неверный выбор операции")

# Решение:
def find_min_max(numbers):
"""Находит минимальный и максимальный элементы в списке."""
if not numbers:
return None, None

min_value = max_value = numbers[0]

for num in numbers:
if num < min_value:
min_value = num
if num > max_value:
max_value = num

return min_value, max_value

# Пример использования
numbers = [int(x) for x in input("Введите числа через пробел: ").split()]
min_num, max_num = find_min_max(numbers)
print(f"Минимальное число: {min_num}")
print(f"Максимальное число: {max_num}")

# Решение:
def remove_duplicates(items):
"""Удаляет дубликаты из списка, сохраняя порядок элементов."""
result = []
seen = set()

for item in items:
if item not in seen:
result.append(item)
seen.add(item)

return result

# Пример использования
items = input("Введите элементы списка через пробел: ").split()
unique_items = remove_duplicates(items)
print(f"Список без дубликатов: {unique_items}")

# Решение:
def sort_list(numbers, reverse=False):
"""Сортирует список чисел по возрастанию или убыванию."""
# Используем алгоритм пузырьковой сортировки для обучения
sorted_numbers = numbers.copy()
n = len(sorted_numbers)

for i in range(n):
for j in range(0, n – i – 1):
# Для сортировки по убыванию меняем знак сравнения
if (sorted_numbers[j] > sorted_numbers[j + 1] and not reverse) or \
(sorted_numbers[j] < sorted_numbers[j + 1] and reverse):
sorted_numbers[j], sorted_numbers[j + 1] = sorted_numbers[j + 1], sorted_numbers[j]

return sorted_numbers

# Пример использования
numbers = [int(x) for x in input("Введите числа через пробел: ").split()]
ascending = sort_list(numbers)
descending = sort_list(numbers, reverse=True)

print(f"Сортировка по возрастанию: {ascending}")
print(f"Сортировка по убыванию: {descending}")

# Решение:
def count_frequency(items):
"""Подсчитывает частоту каждого элемента в списке."""
frequency = {}

for item in items:
if item in frequency:
frequency[item] += 1
else:
frequency[item] = 1

return frequency

# Пример использования
items = input("Введите элементы списка через пробел: ").split()
frequency_dict = count_frequency(items)

print("Частота каждого элемента:")
for item, count in frequency_dict.items():
print(f"{item}: {count}")

# Решение:
def union(list1, list2):
"""Находит объединение двух списков (без дубликатов)."""
return list(set(list1) | set(list2))

def intersection(list1, list2):
"""Находит пересечение двух списков (элементы, присутствующие в обоих списках)."""
return list(set(list1) & set(list2))

# Пример использования
list1 = input("Введите элементы первого списка через пробел: ").split()
list2 = input("Введите элементы второго списка через пробел: ").split()

print(f"Объединение: {union(list1, list2)}")
print(f"Пересечение: {intersection(list1, list2)}")

# Решение:
def reverse_string(text):
"""Переворачивает строку задом наперед."""
return text[::-1]

# Пример использования
text = input("Введите строку для переворота: ")
reversed_text = reverse_string(text)
print(f"Перевернутая строка: {reversed_text}")

# Решение:
def count_words(text):
"""Подсчитывает количество слов в строке."""
# Разбиваем строку по пробелам и считаем непустые элементы
words = [word for word in text.split() if word]
return len(words)

# Пример использования
text = input("Введите строку для подсчета слов: ")
word_count = count_words(text)
print(f"Количество слов в строке: {word_count}")

# Решение:
def are_anagrams(str1, str2):
"""Проверяет, являются ли две строки анаграммами."""
# Удаляем пробелы и приводим к нижнему регистру
str1 = str1.lower().replace(" ", "")
str2 = str2.lower().replace(" ", "")

# Проверяем, имеют ли строки одинаковую длину
if len(str1) != len(str2):
return False

# Сортируем символы в строках и сравниваем результаты
return sorted(str1) == sorted(str2)

# Пример использования
str1 = input("Введите первую строку: ")
str2 = input("Введите вторую строку: ")

if are_anagrams(str1, str2):
print(f"'{str1}' и '{str2}' – анаграммы!")
else:
print(f"'{str1}' и '{str2}' – не анаграммы.")

# Решение:
def is_balanced(expression):
"""Проверяет, правильно ли расставлены скобки в выражении."""
stack = []
brackets = {"(": ")", "[": "]", "{": "}"}

for char in expression:
if char in brackets: # открывающая скобка
stack.append(char)
elif char in brackets.values(): # закрывающая скобка
if not stack or brackets[stack.pop()] != char:
return False

return len(stack) == 0 # все скобки должны быть закрыты

# Пример использования
expression = input("Введите выражение со скобками: ")
if is_balanced(expression):
print("Скобки расставлены правильно!")
else:
print("Скобки расставлены неправильно.")

# Решение:
def phone_book():
"""Реализует простую телефонную книгу с основными операциями."""
contacts = {}

while True:
print("\nТелефонная книга")
print("1. Добавить контакт")
print("2. Найти контакт")
print("3. Удалить контакт")
print("4. Показать все контакты")
print("5. Выход")

choice = input("Выберите действие (1-5): ")

if choice == "1":
name = input("Введите имя контакта: ")
phone = input("Введите номер телефона: ")
contacts[name] = phone
print(f"Контакт {name} добавлен!")

elif choice == "2":
name = input("Введите имя для поиска: ")
if name in contacts:
print(f"{name}: {contacts[name]}")
else:
print(f"Контакт {name} не найден")

elif choice == "3":
name = input("Введите имя для удаления: ")
if name in contacts:
del contacts[name]
print(f"Контакт {name} удален")
else:
print(f"Контакт {name} не найден")

elif choice == "4":
if contacts:
print("\nВсе контакты:")
for name, phone in contacts.items():
print(f"{name}: {phone}")
else:
print("Телефонная книга пуста")

elif choice == "5":
print("До свидания!")
break

else:
print("Неверный выбор. Пожалуйста, выберите 1-5.")

# Запуск телефонной книги
phone_book()

# Решение:
def count_letters(text):
"""Подсчитывает количество каждой буквы в строке."""
letter_count = {}

for char in text.lower():
if char.isalpha(): # проверяем, является ли символ буквой
if char in letter_count:
letter_count[char] += 1
else:
letter_count[char] = 1

return letter_count

# Пример использования
text = input("Введите строку для анализа: ")
letter_frequency = count_letters(text)

print("Частота букв в строке:")
# Сортируем вывод по алфавиту
for letter in sorted(letter_frequency.keys()):
print(f"{letter}: {letter_frequency[letter]}")

# Решение:
def merge_dicts(dict1, dict2):
"""Объединяет два словаря в один."""
result = dict1.copy() # создаем копию первого словаря

for key, value in dict2.items():
if key in result:
# Если ключ уже существует, можно выбрать разные стратегии:
# 1. Оставить значение из первого словаря (ничего не делать)
# 2. Заменить значением из второго словаря (текущая реализация)
# 3. Создать список значений и т.д.
result[key] = value
else:
result[key] = value

return result

# Пример использования
print("Введите первый словарь (формат: ключ1=значение1 ключ2=значение2):")
dict1_input = input().split()
dict1 = {}
for item in dict1_input:
if "=" in item:
key, value = item.split("=", 1)
dict1[key] = value

print("Введите второй словарь (формат: ключ1=значение1 ключ2=значение2):")
dict2_input = input().split()
dict2 = {}
for item in dict2_input:
if "=" in item:
key, value = item.split("=", 1)
dict2[key] = value

merged_dict = merge_dicts(dict1, dict2)
print("Объединенный словарь:")
for key, value in merged_dict.items():
print(f"{key}: {value}")