Давайте создадим код, который будет генерировать небольшую ASCII-анимацию падающей воды. Вместо использования любых специализированных библиотек, мы просто воспользуемся стандартной библиотекой Python.

python
import random
import time

# Ширина нашего "мирового пространства"
WIDTH = 70

# Создаем пустое мировое пространство
world = [' '] * WIDTH

while True:
    # Создаем новый "капельку"
    world[random.randint(0, WIDTH - 1)] = '*'

    # Печатаем текущее состояние мира
    print(''.join(world))

    # Двигаем каждую каплю вниз (если возможно)
    for i in range(WIDTH - 2, -1, -1):
        if world[i] == '*' and world[i + 1] == ' ':
            world[i], world[i + 1] = world[i + 1], world[i]

    # Задержка перед следующим обновлением мира
    time.sleep(0.1)

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

Мы делаем это снова и снова, создавая небольшую анимацию падающих капель.

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

Давайте создадим пример кода, который создает простую текстовую RPG (ролевую игру).

python
class Character:
    def __init__(self, name, health, strength):
        self.name = name
        self.health = health
        self.strength = strength

    def attack(self, other):
        other.health -= self.strength

    def is_alive(self):
        return self.health > 0


def game():
    player = Character("Player", 100, 20)
    monster = Character("Monster", 80, 15)

    while True:
        print(f"Your health: {player.health}, Monster's health: {monster.health}")
        action = input("What will you do? (Attack/Escape) ")

        if action.lower() == "attack":
            player.attack(monster)
            if monster.is_alive():
                monster.attack(player)
            else:
                print("You slayed the monster!")
                break

        elif action.lower() == "escape":
            print("You ran away!")
            break

        if not player.is_alive():
            print("You were slain by the monster!")
            break


game()

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

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

Вот интересный пример использования Python для шифрования текста с помощью простого шифра Цезаря. Шифр Цезаря является одним из самых простых и наиболее широко известных методов шифрования.

python
def caesar_encrypt(text, shift):
    result = ""

    for char in text:
        if char.isalpha():
            ascii_offset = ord('a') if char.islower() else ord('A')
            encrypted_char = chr((ord(char) - ascii_offset + shift) % 26 + ascii_offset)
            result += encrypted_char
        else:
            result += char

    return result

def caesar_decrypt(text, shift):
    return caesar_encrypt(text, -shift)

text = "Hello, World!"
shift = 3

encrypted = caesar_encrypt(text, shift)
print(f"Encrypted: {encrypted}")

decrypted = caesar_decrypt(encrypted, shift)
print(f"Decrypted: {decrypted}")

В этом примере, мы используем функцию caesar_encrypt для шифрования текста с помощью заданного сдвига. Функция caesar_decrypt используется для дешифрования текста, который был зашифрован шифром Цезаря, сдвигая символы в обратную сторону.

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

Давайте напишем код, который моделирует "жизнь клеток" на основе правил "Игры жизни" Джона Конвея. "Игра жизни" - это клеточный автомат, где каждая клетка на двумерной сетке может быть в одном из двух состояний: "живая" или "мёртвая". Состояние каждой клетки на следующем шаге определяется её текущим состоянием и состояниями восьми соседних клеток.

python
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

def update(frameNum, img, grid, N):
    newGrid = grid.copy()
    for i in range(N):
        for j in range(N):
            total = (grid[i, (j-1)%N] + grid[i, (j+1)%N] +
                     grid[(i-1)%N, j] + grid[(i+1)%N, j] +
                     grid[(i-1)%N, (j-1)%N] + grid[(i-1)%N, (j+1)%N] +
                     grid[(i+1)%N, (j-1)%N] + grid[(i+1)%N, (j+1)%N])
            if grid[i, j]  == 1 and (total < 2 or total > 3):
                newGrid[i, j] = 0
            elif grid[i, j] == 0 and total == 3:
                newGrid[i, j] = 1
    img.set_data(newGrid)
    grid[:] = newGrid[:]
    return img,

N = 100
grid = np.random.choice([0,1], N*N, p=[0.9, 0.1]).reshape(N, N)

fig, ax = plt.subplots()
img = ax.imshow(grid, interpolation='nearest')
ani = animation.FuncAnimation(fig, update, fargs=(img, grid, N, ))
plt.show()

В этом коде мы создаем случайную исходную сетку из "живых" и "мёртвых" клеток, затем применяем правила "Игры жизни" для определения следующего состояния сетки. Мы используем matplotlib.animation для создания анимации эволюции сетки.

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

Вот пример кода, который использует Python и библиотеку NumPy для решения системы линейных уравнений.

python
import numpy as np

# Создадим матрицу (левую часть системы)
A = np.array([[3, 1, -2], 
              [1, -1, 4], 
              [2, 0, 3]])

# Создадим вектор-столбец (правую часть системы)
b = np.array([7, -1, 6])

# Используем функцию solve из NumPy для решения системы уравнений
x = np.linalg.solve(A, b)

print("Решение системы:")
print("x =", x[0])
print("y =", x[1])
print("z =", x[2])

Предположим, что у нас есть следующая система линейных уравнений:

3x + y - 2z = 7

x - y + 4z = -1

2x + 3z = 6

Этот код будет находить значения x, y и z, которые удовлетворяют всем трем уравнениям.

Библиотека NumPy - это мощный инструмент для работы с числами и матрицами в Python.

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

Здесь пример кода Python, который реализует простой веб-сервер с использованием библиотеки Flask:

python
from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/')
def home():
    return "Hello, world!"

@app.route('/json')
def json_message():
    return jsonify(message="Hello, JSON")

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

В этом примере мы создаем экземпляр Flask и определяем два маршрута. Первый маршрут ("/") возвращает просто строку "Hello, world!". Второй маршрут ("/json") возвращает JSON-объект с полем message, которое содержит строку "Hello, JSON".

Запустив этот сервер, вы сможете обращаться к нему через ваш веб-браузер или любой другой HTTP-клиент по адресу "http://localhost:5000" (для приветствия) и "http://localhost:5000/json" (для получения JSON-объекта).

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

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

python
class Product:
    def __init__(self, name, quantity):
        self.name = name
        self.quantity = quantity

class Warehouse:
    def __init__(self):
        self.products = []

    def add_product(self, name, quantity):
        self.products.append(Product(name, quantity))

    def list_products(self):
        for product in self.products:
            print(f"Product: {product.name}, Quantity: {product.quantity}")

warehouse = Warehouse()
warehouse.add_product("Apples", 100)
warehouse.add_product("Oranges", 200)
warehouse.list_products()

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

Запуск этого кода создаст склад, добавит на него два продукта и выведет список всех продуктов на складе.

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

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

python
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import classification_report

# Загрузим набор данных
iris = load_iris()

# Разобьем данные на обучающую и тестовую выборку
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42)

# Создадим модель классификатора ближайших соседей
knn = KNeighborsClassifier(n_neighbors=3)

# Обучим модель
knn.fit(X_train, y_train)

# Применим модель на тестовой выборке
y_pred = knn.predict(X_test)

# Выведем отчет о классификации
print(classification_report(y_test, y_pred, target_names=iris.target_names))

Этот код загружает набор данных Iris, который содержит информацию о 150 ирисах, каждый из которых классифицирован как один из трех видов. Мы затем разделяем данные на обучающую и тестовую выборки, создаем модель машинного обучения (в данном случае, классификатор ближайших соседей), обучаем модель на обучающих данных и затем проверяем, насколько хорошо модель работает на тестовых данных.

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

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

python
import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Flatten
from tensorflow.keras.layers import Conv2D, MaxPooling2D

# Загружаем набор данных MNIST
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# Нормализуем данные
x_train, x_test = x_train / 255.0, x_test / 255.0

# Изменяем форму данных, чтобы они были подходящими для использования в модели
x_train = x_train.reshape(x_train.shape[0], 28, 28, 1)
x_test = x_test.reshape(x_test.shape[0], 28, 28, 1)

# Определяем модель
model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))

# Компилируем модель
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

# Обучаем модель
model.fit(x_train, y_train, epochs=5)

# Оцениваем модель
model.evaluate(x_test,  y_test, verbose=2)

Этот скрипт загружает набор данных MNIST, нормализует данные и преобразует их в формат, который может быть использован в нейронной сети. Затем он определяет модель нейронной сети, которая состоит из двух сверточных слоев, максимального слоя объединения, двух полностью связанных слоев и слоя выхода. Модель затем обучается на тренировочных данных и проверяется на тестовых данных.

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

Пример кода на Python, который находит все простые числа от 2 до 100 с помощью решета Эратосфена:

# Создаем список чисел от 2 до 100
numbers = list(range(2, 101))

# Проходимся по списку и удаляем все кратные числа
for i in numbers:
    numbers = [x for x in numbers if ((x == i) or (x % i != 0))]

# Печатаем список простых чисел
print(numbers)

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

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

Пример кода на Python ниже находит все неповторяющиеся комбинации, которые могут быть получены из слова "python":

from itertools import permutations

word = "python"
combinations = set()

# Получаем все перестановки букв в слове
perms = permutations(word)

# Проходимся по каждой перестановке и добавляем неповторяющиеся комбинации в множество
for perm in perms:
    for i in range(len(perm)):
        for j in range(i+1, len(perm)+1):
            combinations.add("".join(perm[i:j]))

# Печатаем все комбинации, отсортированные по алфавиту
for combo in sorted(list(combinations)):
    print(combo)

Этот код использует модуль itertools для получения всех перестановок букв в слове "python". Затем он проходится по каждой перестановке и создает неповторяющиеся комбинации, добавляя их в множество. Наконец, он выводит все комбинации, отсортированные по алфавиту.

Получится список всех возможных неповторяющихся комбинаций, которые можно получить из слова "python". Например: "h", "n", "no", "not", "o", "on", "one", "op", "ot", "oth", "py", "p-y", "p-n", "pno", "po", и т.д.

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

Пример кода на Python ниже решает проблему Traveling Salesman Problem (TSP) с помощью метода динамического программирования:

import sys

# Расстояния между городами
dist = [
    [0, 10, 15, 20],
    [10, 0, 35, 25],
    [15, 35, 0, 30],
    [20, 25, 30, 0]
]

# Размерность матрицы расстояний (количество городов)
N = len(dist)

# Функция для решения TSP с помощью метода динамического программирования
def tsp_dp(dist, start=0):
    # Создаем переменные инициализации
    remaining_cities = set(range(N))
    remaining_cities.remove(start)
    memo = {(frozenset([start]), start): 0}

    # Решаем задачу TSP с помощью метода динамического программирования
    def tsp_helper(visited, curr):
        if (frozenset(visited), curr) in memo:
            return memo[(frozenset(visited), curr)]

        if not visited:
            return dist[curr][start]

        res = sys.maxsize
        for city in remaining_cities:
            if city == curr:
                continue
            distance = dist[curr][city] + tsp_helper(visited | set([city]), city)
            res = min(res, distance)

        memo[(frozenset(visited), curr)] = res
        return res

    # Вызываем функцию tsp_helper, чтобы найти кратчайший маршрут
    return tsp_helper(set(), start)

# Подсчитываем кратчайший маршрут с помощью метода динамического программирования
shortest_route = tsp_dp(dist)
print("Кратчайший маршрут, найденный методом динамического программирования:", shortest_route)

Этот код решает проблему Traveling Salesman Problem (TSP), которая заключается в оптимизации маршрута продажного агента, который должен посетить каждый из нескольких городов и вернуться в исходный город с минимальными затратами на топливо и время. Матрица dist представляет расстояния между городами. Этот код использует метод динамического программирования для поиска кратчайшего маршрута.

В качестве параметра функции tsp_dp() мы передаем матрицу расстояний, а также стартовый город (по умолчанию - город 0). Кратчайший маршрут возвращается из функции и выводится на печать.

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

Пример кода на Python ниже позволяет создать фрактальное дерево, используя библиотеку turtle:

import turtle

# Функция для создания фрактального дерева
def tree(branchLen, t):
    if branchLen > 5:
        t.forward(branchLen)
        t.right(20)
        tree(branchLen-15, t)
        t.left(40)
        tree(branchLen-15, t)
        t.right(20)
        t.backward(branchLen)

# Настройки окна turtle
t = turtle.Turtle()
myWin = turtle.Screen()
t.left(90)
t.up()
t.backward(100)
t.down()
t.color("green")

# Вызов функции для создания фрактального дерева
tree(75, t)

# Закрытие окна turtle при нажатии на экран
myWin.exitonclick()

Этот код использует библиотеку turtle для создания фрактального дерева. Функция tree() вызывается сначала с наибольшей длинной ветви, а затем рекурсивно вызывается дважды с каждым меньшим значением длины ветви. Это приводит к созданию древоподобной структуры, которая напоминает фрактальное дерево.

Настройки окна turtle устанавливают начальную позицию черепашки и цвет линии. Далее вызывается функция tree(), и окно turtle ожидает нажатия на экран, чтобы его закрыть.

Вы можете изменить параметры функции tree() и настройки начальной позиции, цвета линии и т.д. в зависимости от ваших потребностей.

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

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

Мы будем использовать библиотеки requests и BeautifulSoup.

python
import requests
from bs4 import BeautifulSoup

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

    headlines = soup.find_all(['h1', 'h2', 'h3', 'h4', 'h5', 'h6'])  # get all headers

    for headline in headlines:
        print(headline.get_text())  # print header text

get_news_headlines('https://www.bbc.com/news')

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

Учтите: Этот код был написан исключительно в демонстрационных целях и не обеспечивает все необходимые функции безопасности и обработки ошибок, которые должны присутствовать в реальном приложении.

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

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

python
import nltk
from collections import Counter
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize

nltk.download('punkt')
nltk.download('stopwords')

def get_most_common_words(text, num_common_words):
    stop_words = set(stopwords.words('english'))

    word_tokens = word_tokenize(text)

    filtered_text = [word for word in word_tokens if not word in stop_words]

    word_counter = Counter(filtered_text)

    for word, count in word_counter.most_common(num_common_words):
        print(f'Слово "{word}" встречается {count} раз(а)')

text = """
In computing, stop words are words which are filtered out before or after processing of text. 
When building the vocabulary of an information retrieval system, it is a waste of space to include common words like 'is', 'the', and 'an' in the index.
"""

get_most_common_words(text, 5)

Этот скрипт выводит 5 наиболее часто используемых слов в предоставленном тексте, исключая стоп-слова (часто встречающиеся слова, которые обычно игнорируются при обработке текста, такие как "the", "is", "an").

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

Давайте напишем небольшую программу, которая использует API сервиса OpenWeatherMap, чтобы получить текущую погоду для определенного города.

Для использования API OpenWeatherMap вам потребуется ключ API, который вы можете получить, зарегистрировавшись на сайте.

python
import requests

def get_weather(api_key, city):
    base_url = "http://api.openweathermap.org/data/2.5/weather"
    params = {
        "q": city,
        "appid": api_key,
        "units": "metric"
    }
    response = requests.get(base_url, params=params)
    data = response.json()

    main_weather = data['weather'][0]['main']
    description = data['weather'][0]['description']
    temp = data['main']['temp']

    print(f'Погода в {city}: {main_weather} ({description}). Температура: {temp} °C.')

# Замените 'your_api_key' на ваш реальный ключ API
get_weather('your_api_key', 'Moscow')

Этот скрипт делает запрос к API OpenWeatherMap, получает данные о погоде в заданном городе (в этом случае Москва), а затем выводит основную информацию о погоде и температуру. Пожалуйста, не забудьте заменить 'your_api_key' на ваш реальный ключ API.

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

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

Давайте создадим простой чат-бота на Python с использованием библиотеки ChatterBot. ChatterBot использует машинное обучение для генерации ответов на ввод пользователя.

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

pip install chatterbot

Вот пример кода:

python
from chatterbot import ChatBot
from chatterbot.trainers import ChatterBotCorpusTrainer

chatbot = ChatBot('Example Bot')

# Загрузка обучающих данных
trainer = ChatterBotCorpusTrainer(chatbot)
trainer.train(
    "chatterbot.corpus.english.greetings",
    "chatterbot.corpus.english.conversations"
)

while True:
    user_input = input("User: ")
    if user_input.lower() == 'quit':
        break

    response = chatbot.get_response(user_input)
    print(f"Bot: {response}")

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

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

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

Давайте создадим простой скрипт на Python для расшифровки сообщений в коде Цезаря.

Шифр Цезаря - это тип шифра подстановки, в котором каждая буква в исходном тексте сдвигается на определенное количество позиций в алфавите. Например, сдвиг на 1 преобразует "A" в "B".

python
def caesar_decrypt(cipher_text, shift):
    plain_text = ""

    for char in cipher_text:
        if char.isalpha():  # check if character is an alphabet
            ascii_offset = ord('a') if char.islower() else ord('A')
            decrypted_char = chr((ord(char) - ascii_offset - shift) % 26 + ascii_offset)
            plain_text += decrypted_char
        else:
            plain_text += char

    return plain_text

cipher_text = "Bcd efg"
shift = 1
print(caesar_decrypt(cipher_text, shift))  # Outputs: "Abc def"

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

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

Давайте напишем простой вариант игры "Крестики-нолики" на Python.

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

def check_winner(board):
    for row in board:
        if row.count(row[0]) == len(row) and row[0] != " ":
            return True

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

    if board[0][0] == board[1][1] == board[2][2] and board[0][0] != " ":
        return True
    if board[0][2] == board[1][1] == board[2][0] and board[0][2] != " ":
        return True
    return False       

def tictactoe():
    board = [[" " for _ in range(3)] for _ in range(3)]
    player = "X"

    while True:
        print_board(board)
        print(f"Ходит игрок {player}")
        row = int(input("Введите номер строки (1-3): ")) - 1
        col = int(input("Введите номер столбца (1-3): ")) - 1

        if board[row][col] != " ":
            print("Эта ячейка уже занята, попробуйте другую.")
            continue

        board[row][col] = player

        if check_winner(board):
            print(f"Игрок {player} выиграл!")
            break

        player = "O" if player == "X" else "X"

tictactoe()

Этот код создает игру "Крестики-нолики" для двух игроков. Игроки по очереди вводят номер строки и столбца, где они хотят разместить свой символ (X или O). Если игрок удачно формирует линию из трех своих символов (по горизонтали, вертикали или диагонали), он выигрывает игру. Игра продолжается до тех пор, пока не будет объявлен победитель.

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

Давайте напишем небольшой скрипт, который позволит вычислить числа Фибоначчи с помощью концепции рекурсии в Python.

Числа Фибоначчи - это последовательность чисел, в которой каждое следующее число равно сумме двух предыдущих. Первые два числа в этой последовательности - 0 и 1.

python
def fibonacci(n):
    if n <= 0:
        return "Введенное число должно быть больше 0"
    elif n == 1:
        return 0
    elif n == 2:
        return 1
    else:
        return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))  # Outputs: 34

В этом скрипте функция fibonacci принимает один параметр n. Если n равно 1, функция возвращает 0. Если n равно 2, функция возвращает 1. В противном случае функция возвращает сумму двух предыдущих чисел в последовательности, вызывая себя рекурсивно.

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