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

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

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

Давайте создадим простую программу для генерации паролей. Мы будем использовать библиотеку 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 🤖