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

python
class Vehicle:
    def __init__(self, make, model):
        self.make = make
        self.model = model

    def print_details(self):
        print(f"Manufacturer: {self.make}")
        print(f"Model: {self.model}")

class Car(Vehicle):
    def __init__(self, make, model, year):
        super().__init__(make, model)
        self.year = year

    def print_details(self):
        super().print_details()
        print(f"Year: {self.year}")

car = Car("Toyota", "Camry", 2020)
car.print_details()

В этом примере Car является подклассом Vehicle и наследует свойства и методы Vehicle. Однако Car также добавляет новое свойство year и переопределяет метод print_details().

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

python
class Dog:
    def sound(self):
        return "Woof!"

class Cat:
    def sound(self):
        return "Meow!"

def make_sound(animal):
    print(animal.sound())

dog = Dog()
cat = Cat()

make_sound(dog)  # выводит: Woof!
make_sound(cat)  # выводит: Meow!

В этом примере Dog и Cat классы оба имеют метод sound(), но реализуют его по-разному. Функция make_sound(animal) может принимать любой объект, который имеет метод sound(), и вызывать этот метод. Это и есть полиморфизм - один и тот же интерфейс (sound()) используется для объектов разных типов (Dog и Cat).

4. Абстракция - это процесс сокрытия сложности от пользователя, предоставляя ему только функциональность. Один из способов достижения абстракции в Python - использование абстрактных базовых классов (ABC).

python
from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * (self.radius**2)

circle = Circle(5)
print(circle.area())  # выводит: 78.5

В этом примере, Shape является абстрактным базовым классом, который определяет абстрактный метод area(). Этот метод не имеет реализации в Shape, но он должен быть реализован в любом классе, который наследуется от Shape. Circle является подклассом Shape и реализует метод area().

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

Подпишись 👉🏻 @KodduuPython 🤖

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

5. Композиция - это строгий тип ассоциации, когда один класс является частью другого класса.

python
class Engine:
    def __init__(self, type):
        self.type = type

class Car:
    def __init__(self, engine):
        self.engine = engine

engine = Engine("Diesel")
car = Car(engine)

print(car.engine.type)  # выводит: Diesel

В этом примере, класс Engine является частью класса Car, и без экземпляра Engine, Car не может существовать. Это демонстрирует концепцию композиции, где класс Car "включает в себя" класс Engine.

Подпишись 👉🏻 @KodduuPython 🤖

6. Агрегация - это еще один тип ассоциации, который указывает на отношение "имеет" между двумя классами. Он отличается от композиции тем, что классы могут существовать независимо друг от друга.

python
class Address:
    def __init__(self, street, city):
        self.street = street
        self.city = city

class Person:
    def __init__(self, name, address):
        self.name = name
        self.address = address

address = Address("1234 Main St", "Springfield")
person = Person("John Doe", address)

print(person.address.city)  # выводит: Springfield

В этом примере, Person класс имеет Address, но Address может существовать и без Person. Это демонстрирует концепцию агрегации, где Person класс "имеет" Address, но оба класса могут существовать независимо.

Подпишись 👉🏻 @KodduuPython 🤖

Побитовые операторы в Python работают с битами и выполняют битовые операции. Операторы, которые являются побитовыми, включают:

- & (Битовое И)
- | (Битовое ИЛИ)
- ^ (Битовое исключающее ИЛИ)
- ~ (Битовое НЕ)
- << (Сдвиг влево)
- >> (Сдвиг вправо)

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

python
# Инициализация двух чисел
a = 10  # 1010 в бинарном формате
b = 4   # 0100 в бинарном формате

# Битовое И
print("Битовое И: a & b = ", a & b)  # Результат будет 0

# Битовое ИЛИ
print("Битовое ИЛИ: a | b = ", a | b)  # Результат будет 14

# Битовое исключающее ИЛИ
print("Битовое исключающее ИЛИ: a ^ b = ", a ^ b)  # Результат будет 14

# Битовое НЕ
print("Битовое НЕ: ~a = ", ~a)  # Результат будет -11

# Битовый сдвиг влево
print("Сдвиг влево: a << 1 = ", a << 1)  # Результат будет 20

# Битовый сдвиг вправо
print("Сдвиг вправо: a >> 1 = ", a >> 1)  # Результат будет 5

Этот код показывает, как работают различные побитовые операторы в Python.

Подпишись 👉🏻 @KodduuPython 🤖

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

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

python
# Инициализация способностей
CAN_FLY = 1 << 0    # 0001 в бинарном формате
CAN_SWIM = 1 << 1   # 0010 в бинарном формате
CAN_RUN = 1 << 2    # 0100 в бинарном формате

# Начальные способности персонажа
abilities = 0  # В начале персонаж не умеет ничего

# Выдаем персонажу способность летать
abilities |= CAN_FLY

# Проверяем, умеет ли персонаж летать
if abilities & CAN_FLY:
    print("Персонаж умеет летать")

# Отбираем у персонажа способность летать
abilities &= ~CAN_FLY

# Теперь проверка покажет, что персонаж не умеет летать
if not abilities & CAN_FLY:
    print("Персонаж не умеет летать")

# Мы также можем выдать персонажу несколько способностей сразу
abilities |= (CAN_SWIM | CAN_RUN)

# И проверить, умеет ли он плавать и бегать
if abilities & CAN_SWIM and abilities & CAN_RUN:
    print("Персонаж умеет плавать и бегать")

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

Подпишись 👉🏻 @KodduuPython 🤖

Создание игры "Блэкджек" на Python.

## Создание игры "Блэкджек" на Python

### Класс Card

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

python
class Card:
    def __init__(self, suit, rank):
        self.suit = suit
        self.rank = rank

    def __str__(self):
        return self.rank + " of " + self.suit

### Класс Deck

Затем мы создадим класс Deck, который будет представлять колоду карт.

python
import random

class Deck:
    def __init__(self):
        self.deck = []  # начинаем с пустой колоды
        for suit in suits:
            for rank in ranks:
                self.deck.append(Card(suit, rank))

    def __str__(self):
        deck_comp = ''  # начинаем с пустой строки
        for card in self.deck:
            deck_comp += '\n '+card.__str__() # добавляем каждую карту
        return 'The deck has:' + deck_comp

    def shuffle(self):
        random.shuffle(self.deck)

    def deal(self):
        single_card = self.deck.pop()
        return single_card

### Класс Hand

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

python
class Hand:
    def __init__(self):
        self.cards = []  # начинаем с пустого списка, как и в классе Deck
        self.value = 0   # начинаем с нулевого значения
        self.aces = 0    # добавляем атрибут для отслеживания тузов

    def add_card(self,card):
        self.cards.append(card)
        self.value += values[card.rank]

        # отслеживаем тузы
        if card.rank == 'Ace':
            self.aces += 1  

    def adjust_for_ace(self):
        while self.value > 21 and self.aces:
            self.value -= 10
            self.aces -= 1 

### Класс Game

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

python
class Game:
    def __init__(self, deck, player_hand, dealer_hand):
        self.deck = deck
        self.player_hand = player_hand
        self.dealer_hand = dealer_hand

    # здесь будут методы для управления игровым процессом

Подпишись 👉🏻 @KodduuPython 🤖

Вот пример интерактивной игры "Камень, ножницы, бумага" на Python:

python
import random

def game():
    # список возможных выборов
    choices = ["камень", "ножницы", "бумага"]

    while True:
        # случайный выбор компьютера
        computer_choice = random.choice(choices)

        # выбор пользователя
        user_choice = input("Введите 'камень', 'ножницы' или 'бумага' (или 'выход' для выхода): ")
        if user_choice.lower() == 'выход':
            break
        elif user_choice.lower() not in choices:
            print("Неверный ввод. Пожалуйста, попробуйте снова.")
            continue

        print("Компьютер выбрал: " + computer_choice)

        # определение победителя
        if user_choice == computer_choice:
            print("Ничья!")
        elif (user_choice == "камень" and computer_choice == "ножницы") or \
             (user_choice == "ножницы" and computer_choice == "бумага") or \
             (user_choice == "бумага" and computer_choice == "камень"):
            print("Вы выиграли!")
        else:
            print("Вы проиграли!")

game()

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

Подпишись 👉🏻 @KodduuPython 🤖

Вот простой, но интересный пример кода на Python. Это игра "Угадай число", в которой компьютер случайно выбирает число от 1 до 100, а затем пользователь должен его угадать.

python
import random

def game():
    number_to_guess = random.randint(1, 100)
    guess = None
    tries = 0

    while guess != number_to_guess:
        guess = int(input("Угадай число от 1 до 100: "))
        tries += 1
        if guess < number_to_guess:
            print("Слишком мало! Попробуй снова.")
        elif guess > number_to_guess:
            print("Слишком много! Попробуй снова.")
    
    print(f"Поздравляю! Ты угадал число {number_to_guess} за {tries} попыток.")

if __name__ == "__main__":
    game()

В этом коде:

- Импортируется модуль random для генерации случайных чисел.
- Функция game() определяет основную логику игры.
- number_to_guess - это случайное число от 1 до 100, которое пользователь должен угадать.
- guess - это переменная, в которую записывается предположение пользователя.
- tries - счетчик попыток пользователя.
- Цикл while продолжается, пока пользователь не угадает число.
- В цикле пользователю предлагается ввести число, и его ввод преобразуется в целое число с помощью int().
- Затем код проверяет, больше ли предположение пользователя или меньше загаданного числа, и выдает подсказку.
- Если пользователь угадывает число, цикл заканчивается, и игра сообщает пользователю, что он угадал число и сколько попыток это заняло.

Подпишись 👉🏻 @KodduuPython 🤖

Вот ещё один интересный код на Python. Это реализация игры "Крестики-нолики" для двух игроков.

python
def print_board(board):
    for row in board:
        print(" ".join(row))

def check_win(board):
    # Check rows, columns and diagonals for a win
    for row in board:
        if row.count(row[0]) == len(row) and row[0] != ' ':
            return True

    for col in range(len(board)):
        check = []
        for row in board:
            check.append(row[col])
        if check.count(check[0]) == len(check) and check[0] != ' ':
            return True

    if board[0][0] == board[1][1] == board[2][2] != ' ':
        return True
    if board[0][2] == board[1][1] == board[2][0] != ' ':
        return True

    return False


def game():
    board = [[' ' for _ in range(3)] for _ in range(3)]
    current_player = 'X'

    while True:
        print_board(board)
        print(f"Ходит игрок {current_player}")
        row = int(input("Введите номер строки: "))
        col = int(input("Введите номер столбца: "))
        if board[row][col] == ' ':
            board[row][col] = current_player
            if check_win(board):
                print(f"Победил игрок {current_player}!")
                break
            current_player = 'O' if current_player == 'X' else 'X'
        else:
            print("Эта клетка уже занята. Попробуйте снова.")
            continue


if __name__ == "__main__":
    game()

В этом коде:

- Функция print_board печатает игровое поле.
- Функция check_win проверяет наличие победы в текущем состоянии доски.
- Функция game определяет основную логику игры.
- Цикл while True выполняется до тех пор, пока не будет найден победитель или не закончится игра.
- На каждом ходу игрока отображается доска, и игроку предлагается ввести номер строки и столбца, где он хочет поставить свой символ.
- Если клетка свободна, то символ игрока помещается на доску. Если в результате этого хода игрок выигрывает, игра заканчивается. В противном случае ход переходит к другому игроку.
- Если клетка уже занята, игроку сообщается об этом, и он делает ход заново.

Подпишись 👉🏻 @KodduuPython 🤖

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

python
import matplotlib.pyplot as plt
import numpy as np

# Генерируем массив чисел от -π до +π, всего 1000 значений
x = np.linspace(-np.pi, np.pi, 1000)

# Вычисляем значения sin(x) и cos(x)
y_sin = np.sin(x)
y_cos = np.cos(x)

# Создаем график sin(x)
plt.plot(x, y_sin, label='sin(x)')

# Создаем график cos(x)
plt.plot(x, y_cos, label='cos(x)')

# Добавляем легенду
plt.legend()

# Добавляем подписи осей
plt.xlabel('x')
plt.ylabel('y')

# Добавляем заголовок графика
plt.title('Графики sin(x) и cos(x)')

# Отображаем график
plt.show()

В этом коде мы:

- Импортировали библиотеки matplotlib и numpy.
- Сгенерировали массив x из 1000 значений, равномерно распределенных между -π и +π.
- Вычислили значения y_sin и y_cos как sin(x) и cos(x) соответственно.
- Создали два графика с помощью функции plt.plot().
- Добавили легенду, подписи осей и заголовок графика.
- И, наконец, отобразили график с помощью функции plt.show().

Подпишись 👉🏻 @KodduuPython 🤖

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

python
import requests
import json

def get_weather(city):
    # API-ключ (замените на свой!)
    api_key = "your_api_key"

    # URL запроса
    base_url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}"

    # Отправка GET-запроса
    response = requests.get(base_url)

    # Парсинг ответа
    weather_data = response.json()

    # Вывод информации о погоде
    print(f"Погода в городе {city}:")
    print(f"Температура: {weather_data['main']['temp'] - 273.15:.2f} градусов Цельсия")
    print(f"Описание: {weather_data['weather'][0]['description']}")

if __name__ == "__main__":
    city = input("Введите название города: ")
    get_weather(city)

Обратите внимание, что вам нужно получить свой собственный API-ключ от OpenWeatherMap и заменить "your_api_key" на него, чтобы этот код работал.

Прежде чем запускать этот код, убедитесь, что у вас установлены нужные библиотеки (requests и json). Если они еще не установлены, вы можете установить их, используя pip:

pip install requests

Библиотека json входит в стандартную библиотеку Python, поэтому ее устанавливать не нужно.

Подпишись 👉🏻 @KodduuPython 🤖

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

python
import pandas as pd

def load_and_analyze_data(csv_file):
    # Загрузка данных
    data = pd.read_csv(csv_file)

    # Вывод первых 5 строк
    print("Первые 5 строк данных:")
    print(data.head())

    # Вывод информации о данных
    print("\nИнформация о данных:")
    print(data.info())

    # Вывод описательной статистики
    print("\nОписательная статистика:")
    print(data.describe())

    # Вывод количества уникальных значений в каждом столбце
    print("\nКоличество уникальных значений в каждом столбце:")
    print(data.nunique())

if __name__ == "__main__":
    csv_file = input("Введите путь к CSV-файлу: ")
    load_and_analyze_data(csv_file)

Этот скрипт:

- Загружает данные из CSV-файла.
- Выводит первые 5 строк данных.
- Выводит информацию о данных, включая количество строк, типы столбцов и количество непустых значений в каждом столбце.
- Выводит описательную статистику для числовых столбцов (среднее, стандартное отклонение, минимум, 25-й перцентиль, медиана, 75-й перцентиль и максимум).
- Выводит количество уникальных значений в каждом столбце.

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

pip install pandas

Подпишись 👉🏻 @KodduuPython 🤖

В этот раз давайте создадим классическую игру "Змейка" с использованием библиотеки curses в Python.

python
import random
import curses

s = curses.initscr()
curses.curs_set(0)
sh, sw = s.getmaxyx()
w = curses.newwin(sh, sw, 0, 0)
w.keypad(1)
w.timeout(100)

snk_x = sw//4
snk_y = sh//2
snake = [
    [snk_y, snk_x],
    [snk_y, snk_x-1],
    [snk_y, snk_x-2]
]

food = [sh//2, sw//2]
w.addch(int(food[0]), int(food[1]), curses.ACS_PI)

key = curses.KEY_RIGHT

while True:
    next_key = w.getch()
    key = key if next_key == -1 else next_key

    if snake[0][0] in [0, sh] or \
        snake[0][1]  in [0, sw] or \
        snake[0] in snake[1:]:
        curses.endwin()
        quit()

    new_head = [snake[0][0], snake[0][1]]

    if key == curses.KEY_DOWN:
        new_head[0] += 1
    if key == curses.KEY_UP:
        new_head[0] -= 1
    if key == curses.KEY_LEFT:
        new_head[1] -= 1
    if key == curses.KEY_RIGHT:
        new_head[1] += 1

    snake.insert(0, new_head)

    if snake[0] == food:
        food = None
        while food is None:
            nf = [
                random.randint(1, sh-1),
                random.randint(1, sw-1)
            ]
            food = nf if nf not in snake else None
        w.addch(food[0], food[1], curses.ACS_PI)
    else:
        tail = snake.pop()
        w.addch(int(tail[0]), int(tail[1]), ' ')

    w.addch(int(snake[0][0]), int(snake[0][1]), curses.ACS_CKBOARD)

В этом скрипте создается новое окно для игры, змейка и еда. Змейка движется в заданном направлении, пока не столкнется со стеной или сама с собой. Когда змейка ест еду, она становится длиннее, и на поле появляется новая еда. Игра заканчивается, если змейка столкнется со стеной или с собой.

Обратите внимание, что эта игра работает в терминале и может не работать в некоторых интерактивных средах программирования Python, таких как Jupyter Notebook.

Подпишись 👉🏻 @KodduuPython 🤖

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

python
import sqlite3

# Создаем соединение с SQLite и создаем базу данных в памяти
conn = sqlite3.connect(':memory:')

# Создаем курсор для выполнения SQL-запросов
cursor = conn.cursor()

# Создаем таблицу Students
cursor.execute('''
CREATE TABLE Students (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    major TEXT NOT NULL
);
''')

# Функция для добавления студента
def add_student(name, major):
    cursor.execute('''
    INSERT INTO Students (name, major)
    VALUES (?, ?);
    ''', (name, major))

    # Сохраняем изменения
    conn.commit()

# Функция для вывода всех студентов
def print_students():
    cursor.execute('SELECT * FROM Students')
    print('Students:')
    for row in cursor.fetchall():
        print(row)

# Добавляем несколько студентов
add_student('Alice', 'Physics')
add_student('Bob', 'Computer Science')

# Выводим всех студентов
print_students()

# Закрываем соединение с базой данных
conn.close()

В этом коде мы:

- Создаем соединение с SQLite и базу данных в памяти.
- Создаем курсор для выполнения SQL-запросов.
- Создаем таблицу Students с полями id, name и major.
- Создаем функцию add_student для добавления студента.
- Создаем функцию print_students для вывода всех студентов.
- Добавляем несколько студентов и выводим их.
- Закрываем соединение с базой данных.

Обратите внимание, что в этом примере мы использовали базу данных в памяти (':memory:'), но вы можете заменить ее на путь к файлу базы данных на диске, если вы хотите сохранить данные между запусками программы.

Подпишись 👉🏻 @KodduuPython 🤖

Давайте создадим простой чат-бот на Python с использованием библиотеки NLTK (Natural Language Toolkit) для обработки естественного языка.

python
from nltk.chat.util import Chat, reflections

pairs = [
    [
        r"мое имя (.*)",
        ["Привет, %1, как могу помочь?",],
    ],
    [
        r"привет|здравствуй|добрый день",
        ["Привет", "Здравствуй",],
    ],
    [
        r"как дела?",
        ["У меня все хорошо. А у вас?",],
    ],
    [
        r"извини (.*)",
        ["Нет проблем", "Не волнуйся",],
    ],
]

def chatbot():
    print("Привет! Я простой чат-бот. Напишите что-нибудь, чтобы начать общение.")
    
    chat = Chat(pairs, reflections)
    chat.converse()

if __name__ == "__main__":
    chatbot()

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

Если библиотека NLTK не установлена, вы можете установить ее, используя pip:

pip install nltk

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

Подпишись 👉🏻 @KodduuPython 🤖

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

python
def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

print(quicksort([3,6,8,10,1,2,1]))
# Вывод: [1, 1, 2, 3, 6, 8, 10]

В этом примере реализуется алгоритм быстрой сортировки.

Быстрая сортировка - это эффективный алгоритм сортировки с асимптотической сложностью O(n log n). Он использует принцип "разделяй и властвуй" для сортировки списка элементов.

В этом коде мы:

- Выбираем элемент, который станет "опорным". Обычно это средний элемент входного массива.
- Создаем два подмассива: один с элементами меньше опорного, другой с элементами больше опорного.
- Рекурсивно применяем быструю сортировку к двум подмассивам.
- Объединяем отсортированные подмассивы и опорный элемент в один отсортированный массив и возвращаем его.

Подпишись 👉🏻 @KodduuPython 🤖

Давайте создадим программу на Python, которая реализует игру "Угадай число". Программа генерирует случайное число, а пользователь должен его угадать.

python
import random

def guess_the_number():
    number_to_guess = random.randint(1, 100)
    guess = None
    attempts = 0

    while guess != number_to_guess:
        guess = int(input('Введите число от 1 до 100: '))
        attempts += 1
        if guess < number_to_guess:
            print('Ваше число меньше загаданного!')
        elif guess > number_to_guess:
            print('Ваше число больше загаданного!')

    print(f'Поздравляем, вы угадали число {number_to_guess} за {attempts} попыток!')

if __name__ == "__main__":
    guess_the_number()

В этой программе:

- Функция guess_the_number генерирует случайное число от 1 до 100.
- Пользователь вводит число, которое, по его мнению, могло быть загадано.
- Если введенное число меньше или больше загаданного, программа сообщает об этом.
- Процесс повторяется, пока пользователь не угадает число.
- Когда число угадано, программа поздравляет пользователя и сообщает количество попыток, которые потребовались для угадывания числа.

Подпишись 👉🏻 @KodduuPython 🤖

Давайте создадим простую программу на Python для скрапинга данных с веб-страницы. Мы будем использовать библиотеки requests и BeautifulSoup.

python
import requests
from bs4 import BeautifulSoup

def scrape_website(url):
    # Отправляем HTTP-запрос и получаем ответ
    response = requests.get(url)

    # Преобразуем HTML-ответ в объект BeautifulSoup
    soup = BeautifulSoup(response.text, 'html.parser')

    # Ищем все заголовки на веб-странице
    headers = soup.find_all('h1')

    # Печатаем текст каждого заголовка
    for header in headers:
        print(header.get_text())

if __name__ == "__main__":
    url = input("Введите URL-адрес веб-страницы: ")
    scrape_website(url)

Этот скрипт выполняет следующие действия:

1. Получает URL-адрес веб-страницы от пользователя.
2. Отправляет HTTP-запрос на указанный URL-адрес и получает ответ.
3. Преобразует HTML-ответ в объект BeautifulSoup для упрощения парсинга.
4. Ищет все заголовки (<h1>) на веб-странице.
5. Печатает текст каждого найденного заголовка.

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

pip install requests beautifulsoup4