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

Ниже представлен пример кода, который может быть использован для обнаружения людей с использованием HOG (Histogram of Oriented Gradients) дескриптора и SVM (Support Vector Machines) классификатора, включенных в OpenCV. Затем можно было бы использовать обнаруженное положение человека для управления дроном.

python
import cv2
from droneapi import Drone

# Инициализируем дрон
drone = Drone()

# Инициализируем детектор людей
HOGCV = cv2.HOGDescriptor()
HOGCV.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector())

while True:
    # Дрон делает снимок
    frame = drone.capture_image()

    # Обработка изображения с помощью OpenCV и обнаружение людей
    boxes, weights = HOGCV.detectMultiScale(frame, winStride=(4, 4), padding=(8, 8), scale=1.05)

    # Отслеживание первого обнаруженного человека (если есть)
    if len(boxes) > 0:
        x, y, w, h = boxes[0]

        # Простая стратегия следования: если человек слева от центра - поворачиваем налево,
        # если справа - поворачиваем направо
        center_x = x + w / 2
        if center_x < frame.shape[1] / 2:
            drone.turn_left()
        else:
            drone.turn_right()

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

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

Рисование по точкам в виде текста можно осуществить с помощью библиотеки matplotlib. Для начала нам потребуется определить координаты каждой точки, которые формируют буквы надписи "Dart Vader".

Вот пример, как это можно сделать:

python
import matplotlib.pyplot as plt

# Определение координат для надписи "Dart Vader"
# Пожалуйста, замените на реальные координаты
dart_vader_points = {
    'D': [(1, 3), (1, 2), (1, 1), (2, 3), (2, 1), (3, 3), (3, 1), (4, 2)],
    'a': [(6, 2), (6, 1), (7, 3), (7, 1), (8, 2)],
    'r': [(10, 3), (10, 2), (10, 1), (11, 3)],
    't': [(13, 3), (13, 2), (13, 1), (14, 3)],
    'V': [(17, 3), (18, 2), (19, 1), (20, 2), (21, 3)],
    'a2': [(23, 2), (23, 1), (24, 3), (24, 1), (25, 2)],
    'd': [(27, 3), (27, 2), (27, 1), (28, 3), (29, 3), (29, 2), (29, 1)],
    'e': [(31, 3), (31, 2), (31, 1), (32, 3), (32, 1), (33, 3), (33, 2)],
    'r2': [(35, 3), (35, 2), (35, 1), (36, 3)]
}

fig, ax = plt.subplots()

# Рисуем каждую точку
for letter, points in dart_vader_points.items():
    for point in points:
        ax.plot(*point, 'bo')

ax.set_ylim(0, 4)
ax.set_xlim(0, 40)
ax.set_aspect('equal')

plt.gca().invert_yaxis()
plt.show()

Координаты в этом примере являются произвольными и нужно заменить их на реальные координаты для создания надписи "Dart Vader". Это могло бы быть сделано вручную, но это потребует много времени и терпения.

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

Можно использовать библиотеку PIL (Pillow) для чтения пикселей изображения и преобразования их в набор точек.

Возьмем пример с изображением.

python
from PIL import Image
import matplotlib.pyplot as plt

# Открыть изображение и преобразовать в черно-белое
image = Image.open('dart_vader.png').convert('L')

# Преобразовать изображение в массив пикселей
pixels = list(image.getdata())

# Создать пустой список для хранения координат точек
points = []

# Пройтись по всем пикселям изображения
for y in range(image.height):
    for x in range(image.width):
        # Получить интенсивность текущего пикселя (0 - черный, 255 - белый)
        intensity = pixels[y * image.width + x]

        # Если интенсивность ниже определенного порога, добавить координаты в список точек
        if intensity < 128:
            points.append((x, y))

# Отобразить точки на графике
plt.figure(figsize=(10,10))
plt.scatter(*zip(*points), s=1, color='black')
plt.gca().invert_yaxis()
plt.show()

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

Помните, что этот код будет работать только если файл изображения ('dart_vader.png') находится в той же директории, что и Python скрипт. Измените имя файла изображения на имя вашего файла. Вам также может потребоваться установить библиотеку Pillow, если она еще не установлена (это можно сделать с помощью команды pip install pillow в командной строке).

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

Но давайте представим, что вы должны управлять марсоходом напрямую и вам нужно учитывать задержку. Предположим, что ваш MarsRoverAPI имеет методы turn_steering_wheel(angle) и press_gas(amount), где angle это угол поворота в градусах (от -45 до 45), а amount это сколько газа дать (от 0 до 1).

Мы будем использовать asyncio библиотеку для симуляции временной задержки.

python
import asyncio
import MarsRoverAPI # предположим, что такая библиотека существует

class MarsRoverController:

    def __init__(self, signal_delay):
        self.signal_delay = signal_delay
        self.rover = MarsRoverAPI.Rover()

    async def turn(self, angle):
        print(f'Sending turn signal with angle {angle}...')
        await asyncio.sleep(self.signal_delay)  # Wait for the signal to reach Mars
        self.rover.turn_steering_wheel(angle)

    async def press_gas(self, amount):
        print(f'Sending gas signal with amount {amount}...')
        await asyncio.sleep(self.signal_delay)  # Wait for the signal to reach Mars
        self.rover.press_gas(amount)

async def main():
    # Assume signal delay is 10 minutes
    signal_delay = 10 * 60 

    controller = MarsRoverController(signal_delay)

    # send some commands
    await controller.turn(30)
    await controller.press_gas(0.5)

# Run the program
asyncio.run(main())

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

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

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

Вот пример кода на Python, который вычисляет текущее время на планете Марс с использованием модуля datetime:

python
import datetime

# Задаем отношение средних солнечных дней на Земле и Марсе
mars_solar_day = 1.027491252
earth_solar_day = 1

# Получаем текущую дату и время на Земле
current_datetime = datetime.datetime.now()

# Вычисляем количество прошедших секунд на Земле
earth_seconds = (current_datetime.hour * 3600) + (current_datetime.minute * 60) + current_datetime.second

# Вычисляем количество прошедших секунд на Марсе
mars_seconds = earth_seconds * (mars_solar_day / earth_solar_day)

# Конвертируем количество секунд на Марсе в формат времени
mars_time = datetime.timedelta(seconds=mars_seconds)

print(f"Текущее время на Марсе: {mars_time}")

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

1. Инкапсуляция - это концепция, которая заключается в объединении данных и методов, которые работают с этими данными, в одном объекте и скрытии деталей реализации от пользователя.

python
class BankAccount:
    def __init__(self):
        self.__balance = 0  # приватное свойство

    def deposit(self, amount):  # метод для внесения депозита
        self.__balance += amount
        return self.__balance

    def withdraw(self, amount):  # метод для снятия денег
        if amount > self.__balance:
            return "Insufficient funds"
        self.__balance -= amount
        return self.__balance

В этом примере, BankAccount класс инкапсулирует свойства и методы, которые связаны с банковским счетом. Детали реализации, такие как свойство __balance, скрыты от пользователя. Методы deposit и withdraw предоставляют контролируемый доступ к этим данным.

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 🤖