Вот пример кода на 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

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

python
import secrets
import string

def generate_password(length):
    alphabet = string.ascii_letters + string.digits + string.punctuation
    password = ''.join(secrets.choice(alphabet) for i in range(length))
    return password

if __name__ == "__main__":
    password_length = int(input("Введите длину пароля: "))
    print(generate_password(password_length))

В этом коде:

- string.ascii_letters содержит все буквы английского алфавита (заглавные и строчные).
- string.digits содержит все цифры от 0 до 9.
- string.punctuation содержит все символы пунктуации.
- secrets.choice(alphabet) выбирает случайный символ из alphabet.
- Мы повторяем выбор случайного символа length раз, чтобы создать пароль нужной длины.

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

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

Давайте создадим программу, которая реализует алгоритм поиска пути A* для навигации по простой двухмерной сетке.

python
from heapq import heappop, heappush

def heuristic(a, b):
    return abs(b[0] - a[0]) + abs(b[1] - a[1])

def a_star_search(grid, start, goal):
    neighbors = [(0,1),(0,-1),(1,0),(-1,0)]
    close_set = set()
    gscore = {start:0}
    fscore = {start:heuristic(start, goal)}
    oheap = []
    heappush(oheap, (fscore[start], start))
    
    while oheap:
        current = heappop(oheap)[1]

        if current == goal:
            return fscore[goal]
        
        close_set.add(current)
        for i, j in neighbors:
            neighbor = current[0] + i, current[1] + j
            tentative_g_score = gscore[current] + 1
            if 0 <= neighbor[0] < grid.shape[0]:
                if 0 <= neighbor[1] < grid.shape[1]:                
                    if grid[neighbor[0]][neighbor[1]] == 1:
                        continue
                else:
                    continue
            else:
                continue
                
            if neighbor in close_set and tentative_g_score >= gscore.get(neighbor, 0):
                continue
                
            if tentative_g_score < gscore.get(neighbor, 0) or neighbor not in [i[1]for i in oheap]:
                gscore[neighbor] = tentative_g_score
                fscore[neighbor] = tentative_g_score + heuristic(neighbor, goal)
                heappush(oheap, (fscore[neighbor], neighbor))
                
    return False

grid = np.array([
    [0, 1, 0, 0, 0, 0],
    [0, 1, 0, 0, 0, 0],
    [0, 1, 0, 0, 0, 0],
    [0, 0, 0, 0, 1, 0],
    [0, 0, 0, 0, 0, 0],
])

start = (0, 0)
goal = (4, 5)

print(a_star_search(grid, start, goal))

В этом примере:

1. Мы определяем сетку, в которой 0 обозначает открытую клетку, а 1 обозначает заблокированную клетку.
2. Мы задаем начальную и конечную точки.
3. Мы вызываем функцию a_star_search, которая возвращает стоимость кратчайшего пути от начала до конца, если таковой существует.

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

pip install numpy

Как насчет создания простого REST API на Python с использованием Flask? Это будет простое API для работы с пользователями.

python
from flask import Flask, jsonify, request

app = Flask(__name__)

users = []

@app.route('/users', methods=['GET'])
def get_users():
    return jsonify(users)

@app.route('/users', methods=['POST'])
def add_user():
    user = request.json
    users.append(user)
    return {'id': len(users)}, 200

@app.route('/users/<int:user_id>', methods=['GET'])
def get_user(user_id):
    user = users[user_id - 1]
    return user, 200

@app.route('/users/<int:user_id>', methods=['DELETE'])
def delete_user(user_id):
    users.remove(users[user_id - 1])
    return '', 204

if __name__ == "__main__":
    app.run(debug=True)

Это очень простое API с использованием Flask, который включает в себя следующие функции:

- Получение списка всех пользователей (GET /users)
- Добавление нового пользователя (POST /users)
- Получение информации о конкретном пользователе по его ID (GET /users/<user_id>)
- Удаление пользователя по его ID (DELETE /users/<user_id>)

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

Для того чтобы установить Flask, используйте следующую команду pip:

pip install flask

Используйте cURL или Postman для тестирования этого API после его запуска.

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

Давайте создадим простой веб-сервер на Python с использованием базового модуля http.server. Этот веб-сервер будет обрабатывать все запросы и отвечать на них простым текстовым сообщением.

python
from http.server import BaseHTTPRequestHandler, HTTPServer

class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.end_headers()
        self.wfile.write(b'Hello, world!')


def run(server_class=HTTPServer, handler_class=SimpleHTTPRequestHandler, port=8000):
    server_address = ('', port)
    httpd = server_class(server_address, handler_class)
    print(f'Starting httpd server on port {port}')
    httpd.serve_forever()


if __name__ == "__main__":
    run()

Этот скрипт запустит простой веб-сервер на порту 8000 (или на любом другом порту, который вы передадите функции run в качестве аргумента).

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

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

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

python
import csv

def create_csv_file():
    header = ['Name', 'Age', 'Profession']
    data = [
        ['John', '28', 'Engineer'],
        ['Sarah', '32', 'Designer'],
        ['Jim', '35', 'Manager']
    ]

    with open('people.csv', 'w', newline='') as file:
        writer = csv.writer(file)
        writer.writerow(header)
        writer.writerows(data)

    print("CSV file was created successfully!")

if __name__ == "__main__":
    create_csv_file()

В этом коде:

- Мы определяем заголовок CSV файла в списке header.
- Мы определяем данные для CSV файла в списке data.
- Мы открываем файл people.csv в режиме записи.
- Мы создаем объект csv.writer, который облегчает запись данных в CSV.
- Мы пишем заголовок и строки в CSV файл с помощью writerow и writerows.
- Файл закрывается автоматически после завершения блока with.

Этот код создаст файл people.csv в той же директории, где он запущен.

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

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

python
import matplotlib.pyplot as plt
import numpy as np

def draw_plot():
    x = np.linspace(-10, 10, 1000)
    y = np.sin(x)

    plt.plot(x, y)
    plt.title("y = sin(x)")
    plt.xlabel("x")
    plt.ylabel("y")

    plt.grid(True)
    plt.show()

if __name__ == "__main__":
    draw_plot()

В этом коде:

- Мы используем numpy.linspace для создания массива значений x от -10 до 10.
- Мы вычисляем sin(x) для каждого значения в x с помощью numpy.sin.
- Мы строим график y в зависимости от x с помощью matplotlib.pyplot.plot.
- Мы добавляем заголовок и метки осей с помощью title, xlabel и ylabel.
- Мы включаем сетку на графике с помощью grid.
- Мы отображаем график с помощью show.

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

pip install numpy matplotlib

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

python
import cv2

def blur_image():
    # Загружаем изображение
    img = cv2.imread('image.jpg')

    # Применяем гауссово размытие
    blurred_img = cv2.GaussianBlur(img, (15, 15), 0)

    # Сохраняем обработанное изображение
    cv2.imwrite('blurred_image.jpg', blurred_img)

    print("Image has been blurred and saved successfully!")

if __name__ == "__main__":
    blur_image()

В этом коде:

- Мы загружаем изображение с помощью cv2.imread.
- Мы применяем гауссово размытие с помощью cv2.GaussianBlur. Второй аргумент этой функции - это размер ядра, который определяет степень размытия.
- Мы сохраняем обработанное изображение с помощью cv2.imwrite.

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

pip install opencv-python

Также убедитесь, что файл 'image.jpg' находится в той же директории, что и ваш скрипт.

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

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

python
import random

def guess_number():
    number_to_guess = random.randint(1, 100)
    guess = None
    while guess != number_to_guess:
        guess = int(input('Guess a number between 1 and 100: '))
        if guess < number_to_guess:
            print("Too low!")
        elif guess > number_to_guess:
            print("Too high!")
    print("Congratulations! You've guessed the number.")

if __name__ == "__main__":
    guess_number()

В этом коде:

- Мы используем функцию random.randint для генерации случайного числа от 1 до 100.
- Мы используем цикл while для повторения запроса на ввод числа от пользователя, пока он не угадает число.
- Если предположение пользователя ниже загаданного числа, программа выводит "Too low!", если выше - "Too high!".
- Когда пользователь угадывает число, программа выводит "Congratulations! You've guessed the number." и цикл заканчивается.

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

Давайте напишем скрипт на Python, который реализует классический алгоритм сортировки - сортировку пузырьком.

python
def bubble_sort(numbers):
    n = len(numbers)

    for i in range(n):
        for j in range(0, n - i - 1):
            if numbers[j] > numbers[j + 1]:
                numbers[j], numbers[j + 1] = numbers[j + 1], numbers[j]

    return numbers

if __name__ == "__main__":
    numbers = [64, 34, 25, 12, 22, 11, 90]
    sorted_numbers = bubble_sort(numbers)
    print(f"Sorted numbers: {sorted_numbers}")

В этом коде:

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

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

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

Давайте создадим Python скрипт, который будет скачивать файл по URL.

Мы будем использовать библиотеку requests для выполнения HTTP запроса и библиотеку os для работы с файловой системой.

python
import os
import requests

def download_file(url):
    response = requests.get(url, stream=True)
    file_size = int(response.headers.get('Content-Length', 0))

    filename = url.split("/")[-1]

    with open(filename, 'wb') as f:
        for data in response.iter_content(1024):
            f.write(data)

    print(f"'{filename}' has been downloaded successfully!")

if __name__ == "__main__":
    url = 'http://example.com/bigfile.dat'  # Replace with your file URL
    download_file(url)

В этом коде:

- Мы создаем GET запрос к URL, указанному в аргументе url.
- Мы получаем размер файла из заголовков ответа.
- Мы извлекаем имя файла из URL.
- Мы открываем файл для записи в бинарном режиме.
- Мы записываем данные в файл по мере их получения.
- В конце мы выводим сообщение о том, что файл успешно скачан.

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

pip install requests

Также замените http://example.com/bigfile.dat на URL файла, который вы хотите скачать.

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

Давайте напишем скрипт, который будет извлекать все ссылки с веб-страницы с использованием модулей requests и BeautifulSoup.

python
import requests
from bs4 import BeautifulSoup

def extract_links(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')

    for link in soup.find_all('a'):
        href = link.get('href')
        if href.startswith('http'):
            print(href)

if __name__ == "__main__":
    url = 'http://example.com'  # Replace with your URL
    extract_links(url)

В этом коде:

- Мы делаем GET запрос к указанному URL.
- Мы создаем объект BeautifulSoup из HTML содержимого ответа.
- Мы находим все теги a (ссылки) на веб-странице с помощью метода find_all.
- Мы извлекаем атрибут href из каждой ссылки, который представляет собой URL.
- Если URL начинается с http, мы выводим его.

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

pip install requests beautifulsoup4

Также замените http://example.com на URL веб-страницы, с которой вы хотите извлечь ссылки.

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

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

python
import random

class ChatBot:
    RESPONSES = [
        "Привет!",
        "Здравствуйте!",
        "Добро пожаловать!",
        "Рад видеть вас!",
        "Приветствую вас!"
    ]

    def greet(self):
        print(random.choice(self.RESPONSES))

if __name__ == "__main__":
    bot = ChatBot()
    while True:
        user_input = input("> ")
        if user_input.lower() in ["привет", "здравствуйте", "добрый день", "добро пожаловать"]:
            bot.greet()
        elif user_input.lower() in ["стоп", "выход", "пока"]:
            break
        else:
            print("Извините, я вас не понимаю.")

В этом коде:

- У нас есть класс ChatBot, который имеет список возможных ответов на приветствия.
- Функция greet выводит случайный ответ из списка.
- В основном блоке кода мы создаем экземпляр чат-бота.
- Мы запрашиваем ввод от пользователя в бесконечном цикле.
- Если ввод пользователя содержит приветствие, бот отвечает приветствием.
- Если ввод пользователя содержит слово для выхода, цикл прекращается.
- Если бот не понимает ввод, он выводит сообщение об ошибке.

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

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

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()

    visited.add(start)

    print(start)

    for next_node in graph[start] - visited:
        dfs(graph, next_node, visited)

    return visited


if __name__ == "__main__":
    graph = {'A': set(['B', 'C']),
             'B': set(['A', 'E']),
             'C': set(['A', 'F']),
             'E': set(['B', 'F']),
             'F': set(['C', 'E'])}

    dfs(graph, 'A')

В этом коде:

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

Запуск этого кода отобразит последовательность вершин, посещенных при обходе в глубину, начиная с вершины 'A'.

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