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

# Словарь для хранения геномов
genomes = {
    "human": "ATCGCGTACGATCGATCGATCAGCTAGCTAGCTCGATCGTAGCTAGTAGCTAGCTAG",
    "mouse": "CGTAGCTAGCTAGCTACGATCGATCGTAGCTAGCTAGCTAGCTACGATCAGCTAGCT",
    "fruit_fly": "GCTAGCTAGCTAGCTACGATCGATCGATCGTAGCTAGCTAGCTAGCTAGCTACGATC"
}

# Функция для поиска гена в геноме
def find_gene(genome_name, gene_sequence):
    genome = genomes.get(genome_name, "")
    position = genome.find(gene_sequence)
    if position != -1:
        print(f"Ген найден в геноме {genome_name} на позиции {position}.")
    else:
        print(f"Ген не найден в геноме {genome_name}.")

# Примеры поиска генов
find_gene("human", "GATCGA")
find_gene("mouse", "TAGCTA")
find_gene("fruit_fly", "CGATCG")

В этом коде:
- Мы создали словарь genomes, где ключами являются названия видов, а значениями - строковые представления их геномов. Геномы здесь сильно упрощены для демонстрации.
- Функция find_gene принимает название генома и последовательность гена, который нужно найти. Она использует метод .find() строки для определения позиции гена в геноме, если такой ген присутствует.
- Последние три строки демонстрируют использование функции find_gene для поиска различных генов в геномах трёх видов.

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

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

В Python есть несколько мощных библиотек для работы с геномными данными. Одной из наиболее известных является Biopython, комплексный инструментарий для биологических вычислений. Он предоставляет функционал для чтения, записи и анализа геномных данных, включая работу с последовательностями ДНК, РНК и белков.

Давайте рассмотрим пример использования Biopython для работы с геномными данными. В этом примере мы сосредоточимся на поиске конкретных последовательностей в ДНК.

Прежде чем начать, убедитесь, что у вас установлен Biopython. Если нет, его можно установить через pip:

pip install biopython

Теперь давайте напишем код, который демонстрирует базовую работу с ДНК:

from Bio.Seq import Seq
from Bio import SeqIO

# Пример работы с ДНК последовательностью
dna_seq = Seq("ATGCGTACGATCGATCGATCAGCTAGCTAGCTCGATCGTAGCTAGTAGCTAGCTAG")

# Вывод информации о последовательности
print(f"ДНК последовательность: {dna_seq}")
print(f"Длина последовательности: {len(dna_seq)}")
print(f"Комплементарная последовательность: {dna_seq.complement()}")
print(f"Реверс-комплементарная последовательность: {dna_seq.reverse_complement()}")

# Поиск подпоследовательности
sub_seq = "GATCGA"
if sub_seq in dna_seq:
    print(f"Подпоследовательность {sub_seq} найдена в ДНК.")
else:
    print(f"Подпоследовательность {sub_seq} не найдена в ДНК.")

# Чтение геномной последовательности из файла (пример)
# Предположим, что у нас есть файл "example.fasta" с геномными данными
# for record in SeqIO.parse("example.fasta", "fasta"):
#     print(record.id)
#     print(record.seq)

В этом коде:
- Мы создаем объект Seq, который представляет последовательность ДНК.
- Выводим базовую информацию о последовательности: её саму, её длину, комплементарную и реверс-комплементарную последовательности.
- Ищем подпоследовательность в нашей ДНК.
- В комментариях показан пример, как можно читать последовательности из файла в формате FASTA. Это часто используемый формат для хранения геномных данных.

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

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

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

Допустим, мы выбрали следующие гены:
- ACTN3: Ген, связанный с мышечной силой и выносливостью.
- MTHFR: Ген, влияющий на обмен веществ и репарацию ДНК.
- APOE: Ген, связанный с долголетием и здоровьем мозга.

Мы создадим упрощенные версии этих генов как последовательности ДНК и объединим их в один "геном суперчеловека". Также добавим короткие описательные метки к каждому гену в геноме для идентификации.

from Bio.SeqRecord import SeqRecord
from Bio.Seq import Seq
from Bio import SeqIO

# Упрощенные последовательности генов
genes = {
    "ACTN3": "ATGCGTACTG",
    "MTHFR": "CGTAGCTAGC",
    "APOE": "GCTAGCTAGC"
}

# Создание последовательности генома суперчеловека
superhuman_genome_sequence = "".join(genes.values())

# Создание описательных меток для генов в геноме
descriptions = {
    "ACTN3": "Мышечная сила и выносливость",
    "MTHFR": "Обмен веществ и репарация ДНК",
    "APOE": "Долголетие и здоровье мозга"
}

# Создание SeqRecord для генома суперчеловека
superhuman_genome = SeqRecord(
    Seq(superhuman_genome_sequence),
    id="00001",
    name="Superhuman",
    description="Геном суперчеловека с генами ACTN3, MTHFR, APOE"
)

# Печать информации о геноме суперчеловека
print(f"ID: {superhuman_genome.id}")
print(f"Name: {superhuman_genome.name}")
print(f"Description: {superhuman_genome.description}")
print(f"Sequence: {superhuman_genome.seq}")

# Для сохранения генома в файл FASTA (раскомментируйте следующие строки)
# with open("superhuman_genome.fasta", "w") as output_handle:
#     SeqIO.write(superhuman_genome, output_handle, "fasta")

В этом примере:
- Мы сначала определяем упрощенные последовательности для трех генов.
- Затем мы объединяем эти последовательности в одну, чтобы сформировать "геном суперчеловека".
- Создаем объект SeqRecord для этой последовательности, добавляя идентификатор, имя и описание, которые включают информацию о составляющих генах.
- Выводим информацию о созданном геноме.
- Комментарии содержат код для сохранения этой последовательности в файл формата FASTA, что может быть полезно для последующего анализа или работы.

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

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

Вот пример простого Telegram бота, использующего python-telegram-bot версии 20.7. В этом примере бот будет реагировать на команду /start, отправляя пользователю приветственное сообщение, а также будет эхо-отвечать на любые текстовые сообщения, полученные от пользователя.

from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes

# Асинхронная функция, обрабатывающая команду /start
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await context.bot.send_message(chat_id=update.effective_chat.id, text="Привет! Я твой эхо-бот.")

# Асинхронная функция для эхо-ответа на текстовые сообщения
async def echo(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    text = update.message.text
    await update.message.reply_text(text)

# Основная функция, где происходит настройка и запуск бота
async def main() -> None:
    # Создание экземпляра Application и передача токена вашего бота
    application = Application.builder().token("YOUR_BOT_TOKEN").build()

    # Добавление обработчика команды /start
    application.add_handler(CommandHandler("start", start))

    # Добавление обработчика для эхо-ответов на текстовые сообщения
    application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo))

    # Запуск бота
    await application.run_polling()

if __name__ == '__main__':
    import asyncio
    asyncio.run(main())

Чтобы этот код работал, вам нужно заменить "YOUR_BOT_TOKEN" на токен, который вы получили от @BotFather при создании вашего Telegram бота.

### Ключевые моменты:

- В версии 20.7 используется асинхронный подход с async/await для обработки команд и сообщений.
- Application.builder().token("YOUR_BOT_TOKEN").build() создает экземпляр приложения для вашего бота с указанным токеном.
- CommandHandler и MessageHandler используются для обработки команд и текстовых сообщений соответственно.
- Фильтры применяются непосредственно в MessageHandler для определения типа сообщений, на которые должен реагировать бот (в данном случае, на текстовые сообщения, не являющиеся командами).
- await application.run_polling() запускает бота в режиме опроса серверов Telegram для получения новых сообщений.

Убедитесь, что у вас установлена требуемая версия библиотеки python-telegram-bot:

sh
pip install python-telegram-bot==20.7

Этот пример демонстрирует базовую структуру асинхронного Telegram бота с использованием современного API библиотеки python-telegram-bot.

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

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

### Шаг 1: Создание приложения в Slack

Перед началом программирования вам нужно создать приложение в Slack:

1. Перейдите на [страницу создания приложений Slack](https://api.slack.com/apps) и нажмите "Create New App".
2. Выберите "From scratch", дайте имя вашему приложению и выберите рабочее пространство.
3. В настройках приложения перейдите в раздел "OAuth & Permissions" и добавьте необходимые разрешения (например, chat:write для отправки сообщений).
4. Установите приложение в ваше рабочее пространство и скопируйте "Bot User OAuth Token" для использования в коде.

### Шаг 2: Установка slack_bolt

Установите библиотеку slack_bolt через pip:

sh
pip install slack_bolt

### Шаг 3: Создание скрипта бота

Создайте скрипт Python, в котором будет реализована логика бота. Бот будет слушать сообщения в канале и отвечать на них:

from slack_bolt import App

# Инициализация приложения с токеном бота
app = App(token="xoxb-ваш-bot-user-oauth-token")

# Функция обработчика сообщений
@app.message("привет")
def message_hello(message, say):
    # Ответ на сообщение
    say(f"Привет, <@{message['user']}>!")

if __name__ == "__main__":
    # Запуск приложения на порте 3000
    app.start(port=3000)

Замените "xoxb-ваш-bot-user-oauth-token" на реальный токен OAuth вашего бота.

### Шаг 4: Запуск бота

Запустите скрипт. Бот будет слушать сообщения в каналах, где он добавлен, и если кто-то напишет "привет", бот ответит приветствием.

### Дополнительные шаги

В реальном приложении вам может понадобиться настроить внешний URL для вашего бота, чтобы Slack мог отправлять ему события через интернет. Это можно сделать с помощью таких инструментов, как [ngrok](https://ngrok.com/), который позволяет туннелировать трафик на локальный сервер.

Для более подробной информации и дополнительных возможностей рекомендую ознакомиться с [официальной документацией Slack API](https://api.slack.com/start) и [документацией по slack_bolt](https://slack.dev/bolt-python/tutorial/getting-started).

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

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

### Предупреждение

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

### Шаг 1: Регистрация на Binance и получение API ключей

1. Зарегистрируйтесь на [Binance](https://www.binance.com/).
2. Перейдите в раздел "API Management" в вашем аккаунте и создайте новый API ключ.
3. Запишите API Key и Secret Key.

### Шаг 2: Установка библиотеки python-binance

sh
pip install python-binance

### Шаг 3: Создание скрипта торгового бота

from binance.client import Client
from binance.enums import *

api_key = 'ваш_api_key'
api_secret = 'ваш_secret_key'

client = Client(api_key, api_secret)

# Пример простой торговой функции
def check_order(symbol, quantity, price):
    # Проверка условий для размещения ордера
    # Это пример, добавьте свою логику
    if price > 10000:
        order = client.create_order(
            symbol=symbol,
            side=SIDE_BUY,
            type=ORDER_TYPE_LIMIT,
            timeInForce=TIME_IN_FORCE_GTC,
            quantity=quantity,
            price=str(price)
        )
        return order
    else:
        print("Условия для ордера не выполнены.")

# Пример выполнения
symbol = 'BTCUSDT'
quantity = 0.001
price = 10000  # Пример цены, измените на актуальную

order_result = check_order(symbol, quantity, price)
if order_result:
    print("Ордер размещен:", order_result)

### Объяснение кода

- Мы используем python-binance, официальную библиотеку Python для работы с Binance API.
- api_key и api_secret - это ваши ключи для доступа к API.
- Функция check_order проверяет условия (в этом примере, условие с ценой) перед размещением ордера на покупку. В реальном боте условия будут зависеть от вашей торговой стратегии.
- create_order используется для размещения ордера на покупку. Мы используем лимитный ордер (ORDER_TYPE_LIMIT), который позволяет указать цену покупки.

### Важно

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

Этот пример дает базовое представление о том, как начать работу с созданием торгового бота для Binance. Развивайте и адаптируйте этот код в соответствии с ваш

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

Создание торгового бота для Московской Биржи (МОСБИРЖ) требует глубоких знаний в области торговли, программирования и понимания регуляторных требований. Однако, в качестве образовательного примера, я могу показать, как начать создание простого торгового бота на Python, используя открытые API или библиотеки, если таковые доступны.

### Важное примечание:
- Реальная торговля на финансовых рынках связана с риском потери капитала.
- Вам необходимо соблюдать все регуляторные требования и условия использования Московской Биржи.
- Этот пример не использует реальный торговый API МОСБИРЖЕ, так как доступ к нему обычно ограничен и требует регистрации и согласования с биржей.

### Шаг 1: Подготовка
Перед началом работы убедитесь, что у вас установлен Python и необходимые библиотеки. Для работы с HTTP запросами установите requests:

sh
pip install requests

### Шаг 2: Пример кода
Допустим, у вас есть доступ к некоторому API, который предоставляет информацию о ценах акций на МОСБИРЖЕ. В этом примере мы создадим простую функцию, которая проверяет текущую цену акции и принимает решение о покупке или продаже на основе предопределенных условий.

import requests

# Замените эти значения на реальные данные API
API_URL = "https://api.example.com/market/data"
API_KEY = "your_api_key_here"

def get_stock_price(stock_symbol):
    """Получение текущей цены акции."""
    response = requests.get(f"{API_URL}/{stock_symbol}", headers={"Authorization": f"Bearer {API_KEY}"})
    data = response.json()
    return data['price']

def make_decision(stock_symbol):
    """Принятие решения о покупке/продаже."""
    price = get_stock_price(stock_symbol)
    print(f"Текущая цена {stock_symbol}: {price}")

    # Простая логика торговли: псевдокод
    if price < 100:  # Предполагаемая логика для покупки
        print(f"Покупаем {stock_symbol}")
        # здесь код для покупки
    elif price > 200:  # Предполагаемая логика для продажи
        print(f"Продаем {stock_symbol}")
        # здесь код для продажи

# Пример использования
stock_symbol = "SBER"  # Пример символа акции
make_decision(stock_symbol)

### Шаг 3: Реализация торговой логики
Реальная торговая логика должна быть основана на тщательном анализе и может включать различные финансовые индикаторы, исторические данные, модели машинного обучения и управление рисками.

### Шаг 4: Тестирование и оптимизация
Перед запуском торгового бота на реальных средствах его следует тщательно протестировать в демо-режиме или с использованием исторических данных.

### Заключение
Этот пример является базовым и демонстрирует принцип создания торгового бота.

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

Для создания бота, который извлекает информацию из JIRA, можно использовать JIRA REST API. В этом примере будет показано, как написать простого бота на Python, который авторизуется в JIRA и извлекает информацию о задачах (issues).

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

### Шаг 1: Установка необходимых библиотек

Для работы с HTTP запросами установите библиотеку requests:

sh
pip install requests

### Шаг 2: Создание скрипта для подключения к JIRA

import requests
from requests.auth import HTTPBasicAuth
import json

# Замените эти значения на реальные данные
JIRA_URL = "https://yourdomain.atlassian.net"
API_TOKEN = "your_api_token"
EMAIL = "your_email@example.com"

# Аутентификация
auth = HTTPBasicAuth(EMAIL, API_TOKEN)

# Заголовки
headers = {
   "Accept": "application/json"
}

def get_issues(project_key):
    """Получение списка задач для указанного проекта."""
    query = {
        'jql': f'project = "{project_key}"'
    }
    
    response = requests.request(
        "GET",
        f"{JIRA_URL}/rest/api/3/search",
        headers=headers,
        params=query,
        auth=auth
    )
    
    # Проверка успешности запроса
    if response.status_code == 200:
        data = response.json()
        issues = data['issues']
        for issue in issues:
            print(f"- {issue['key']}: {issue['fields']['summary']}")
    else:
        print("Ошибка при получении данных из JIRA:", response.status_code)

# Пример использования
project_key = "TEST"
get_issues(project_key)

Этот скрипт выполняет запрос к JIRA REST API для получения списка задач (issues) в указанном проекте. Вам нужно заменить JIRA_URL, API_TOKEN, и EMAIL на актуальные данные вашей учетной записи и проекта в JIRA. Также, замените project_key на ключ вашего проекта в JIRA, для которого вы хотите получить список задач.

### Шаг 3: Расширение функционала

Вы можете расширить функционал бота, добавив возможность получения более детальной информации по каждой задаче, изменения задач через API, создания новых задач и так далее, в зависимости от ваших нужд. Ознакомьтесь с [официальной документацией JIRA REST API](https://developer.atlassian.com/cloud/jira/platform/rest/v3/) для изучения всех возможностей.

### Важно

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

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

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

### Шаг 1: Подготовка

Перед тем, как начать, убедитесь, что у вас установлен Python. Создайте новый файл, например goals_bot.py, и откройте его в вашем любимом текстовом редакторе.

### Шаг 2: Код бота

class Goal:
    def __init__(self, description):
        self.description = description
        self.is_completed = False

    def complete(self):
        self.is_completed = True

    def __str__(self):
        status = "Выполнено" if self.is_completed else "В процессе"
        return f"{self.description} - {status}"


class GoalsBot:
    def __init__(self):
        self.goals = []

    def add_goal(self, description):
        self.goals.append(Goal(description))
        print(f"Цель '{description}' добавлена.")

    def complete_goal(self, index):
        if 0 <= index < len(self.goals):
            self.goals[index].complete()
            print(f"Цель '{self.goals[index].description}' выполнена!")
        else:
            print("Некорректный индекс цели.")

    def show_goals(self):
        if self.goals:
            print("\nВаши цели:")
            for index, goal in enumerate(self.goals):
                print(f"{index}. {goal}")
        else:
            print("У вас пока нет целей.")

    def run(self):
        while True:
            print("\nСлово пацана: цели на асфальте")
            print("1. Добавить цель")
            print("2. Отметить цель как выполненную")
            print("3. Показать все цели")
            print("4. Выйти")
            choice = input("Выберите действие: ")

            if choice == '1':
                description = input("Введите описание цели: ")
                self.add_goal(description)
            elif choice == '2':
                self.show_goals()
                index = int(input("Введите номер выполненной цели: "))
                self.complete_goal(index)
            elif choice == '3':
                self.show_goals()
            elif choice == '4':
                print("До новых встреч!")
                break
            else:
                print("Некорректный выбор, попробуйте снова.")

if __name__ == "__main__":
    bot = GoalsBot()
    bot.run()

### Шаг 3: Запуск бота

Запустите созданный файл в консоли или терминале:

sh
python goals_bot.py

### Функционал бота

- Добавление цели: пользователь может добавить новую цель, введя ее описание.
- Отметить цель как выполненную: пользователь может отметить любую из своих целей как выполненную, введя ее номер.
- Показать все цели: отображает список всех целей пользователя вместе с их статусом (выполнено/в процессе).
- Выход: завершает работу программы.

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

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

Создание сайта объявлений, такого как Avito или Craigslist, включает в себя несколько ключевых шагов и компонентов, включая работу с базой данных, создание интерфейса пользователя и обработку пользовательских запросов. Я покажу вам базовый пример на Python, используя Flask для веб-сервера и SQLite для базы данных. Этот пример будет включать основные функции, такие как добавление объявлений и просмотр списка объявлений.

### Шаг 1: Установка необходимых библиотек

Вам нужно будет установить Flask и другие необходимые библиотеки. Это можно сделать с помощью pip:

bash
pip install Flask Flask-SQLAlchemy

### Шаг 2: Создание приложения Flask

Создайте файл, например app.py, и добавьте в него следующий код:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask import Flask, request, render_template, redirect, url_for

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///ads.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

class Ad(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    description = db.Column(db.String(1000), nullable=False)

initialized = False

@app.before_request
def before_first_request():
    global initialized
    if not initialized:
        db.create_all()
        initialized = True

@app.route('/')
def index():
    ads = Ad.query.all()
    return render_template('index.html', ads=ads)

@app.route('/add', methods=['GET', 'POST'])
def add_ad():
    if request.method == 'POST':
        title = request.form['title']
        description = request.form['description']
        ad = Ad(title=title, description=description)
        db.session.add(ad)
        db.session.commit()
        return redirect(url_for('index'))
    return render_template('add.html')

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

### Шаг 3: Создание шаблонов HTML

Создайте папку templates рядом с app.py и добавьте в нее следующие файлы:

index.html

html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Объявления</title>
</head>
<body>
    <h1>Объявления</h1>
    <a href="/add">Добавить объявление</a>
    <ul>
        {% for ad in ads %}
            <li>{{ ad.title }}: {{ ad.description }}</li>
        {% endfor %}
    </ul>
</body>
</html>

add.html

html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Добавить объявление</title>
</head>
<body>
    <h1>Добавить объявление</h1>
    <form method="post">
        Название: <input type="text" name="title"><br>
        Описание: <textarea name="description"></textarea><br>
        <input type="submit" value="Добавить">
    </form>
    <a href="/">Вернуться к списку объявлений</a>
</body>
</html>

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

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

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

### Шаг 1: Установка необходимых библиотек

Убедитесь, что у вас установлены sqlite3 и Flask, если вы хотите создать веб-интерфейс для ввода и просмотра данных. SQLite уже входит в стандартную библиотеку Python, поэтому вам может потребоваться только установить Flask:

bash
pip install flask

### Шаг 2: Создание модели данных

Создайте файл, например app.py, и определите в нем структуру базы данных:

import sqlite3
from flask import Flask, request, g, render_template, redirect, url_for

DATABASE = 'crash_tests.db'
app = Flask(__name__)

def get_db():
    db = getattr(g, '_database', None)
    if db is None:
        db = g._database = sqlite3.connect(DATABASE)
    return db

@app.teardown_appcontext
def close_connection(exception):
    db = getattr(g, '_database', None)
    if db is not None:
        db.close()

def init_db():
    with app.app_context():
        db = get_db()
        cursor = db.cursor()
        cursor.execute('''CREATE TABLE IF NOT EXISTS crash_tests (
                            id INTEGER PRIMARY KEY,
                            make TEXT,
                            model TEXT,
                            year INTEGER,
                            safety_rating INTEGER)''')
        db.commit()

@app.route('/')
def index():
    db = get_db()
    cursor = db.cursor()
    cursor.execute("SELECT * FROM crash_tests")
    tests = cursor.fetchall()
    return render_template('index.html', tests=tests)

@app.route('/add', methods=['GET', 'POST'])
def add_test():
    if request.method == 'POST':
        db = get_db()
        cursor = db.cursor()
        cursor.execute("INSERT INTO crash_tests (make, model, year, safety_rating) VALUES (?, ?, ?, ?)",
                       (request.form['make'], request.form['model'], int(request.form['year']), int(request.form['safety_rating'])))
        db.commit()
        return redirect(url_for('index'))
    return render_template('add.html')

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

### Шаг 3: Создание шаблонов для веб-интерфейса

Создайте папку templates рядом с вашим app.py и добавьте в нее следующие файлы для базового интерфейса.

index.html

html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Crash Test Results</title>
</head>
<body>
    <h1>Crash Test Results</h1>
    <a href="/add">Add New Test</a>
    <ul>
        {% for test in tests %}
            <li>{{ test[1] }} {{ test[2] }}, {{ test[3] }}: Safety Rating {{ test[4] }}</li>
        {% endfor %}
    </ul>
</body>
</html>

add.html

html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Add Crash Test</title>
</head>
<body>
    <h1>Add a New Crash Test Result</h1>
    <form method="post">
        Make: <input type="text" name="make"><br>
        Model: <input type="text" name="model"><br>
        Year: <input type="number" name="year"><br>
        Safety Rating (1-5): <input type="number" name="safety_rating" min="1" max="5"><br>
        <input type="submit" value="Add Test">
    </form>
    <a href="/">Back to List</a>
</body>
</html>

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

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

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

### Шаг 1: Создание базы данных

Сначала определим структуру базы данных и создадим её. Ниже приведен код для инициализации базы данных:

import sqlite3

def init_db():
    conn = sqlite3.connect('quotes.db')
    c = conn.cursor()
    c.execute('''CREATE TABLE IF NOT EXISTS actors (
                 id INTEGER PRIMARY KEY,
                 name TEXT NOT NULL)''')
    c.execute('''CREATE TABLE IF NOT EXISTS quotes (
                 id INTEGER PRIMARY KEY,
                 actor_id INTEGER,
                 quote TEXT NOT NULL,
                 FOREIGN KEY (actor_id) REFERENCES actors (id))''')
    conn.commit()
    conn.close()

init_db()

### Шаг 2: Наполнение базы данных

Для демонстрации добавим несколько актеров и цитат вручную. Вы можете добавить больше данных по своему усмотрению.

python
def add_sample_data():
    actors = [('Morgan Freeman',), ('Tom Hanks',)]
    quotes = [
        (1, "Get busy living, or get busy dying."),
        (2, "Life is like a box of chocolates, you never know what you're gonna get.")
    ]
    conn = sqlite3.connect('quotes.db')
    c = conn.cursor()
    c.executemany('INSERT INTO actors (name) VALUES (?)', actors)
    c.executemany('INSERT INTO quotes (actor_id, quote) VALUES (?, ?)', quotes)
    conn.commit()
    conn.close()

add_sample_data()

### Шаг 3: Создание Flask приложения

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

python
from flask import Flask, render_template, request, redirect, url_for
import sqlite3
import random

app = Flask(__name__)

@app.route('/', methods=['GET', 'POST'])
def index():
    if request.method == 'POST':
        actor_id = request.form.get('actor')
        return redirect(url_for('quote', actor_id=actor_id))
    else:
        conn = sqlite3.connect('quotes.db')
        c = conn.cursor()
        c.execute('SELECT * FROM actors')
        actors = c.fetchall()
        conn.close()
        return render_template('index.html', actors=actors)

@app.route('/quote/<int:actor_id>')
def quote(actor_id):
    conn = sqlite3.connect('quotes.db')
    c = conn.cursor()
    c.execute('SELECT quote FROM quotes WHERE actor_id=? ORDER BY RANDOM() LIMIT 1', (actor_id,))
    quote = c.fetchone()
    conn.close()
    return render_template('quote.html', quote=quote[0] if quote else "No quotes found.")

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

### Шаг 4: Создание шаблонов HTML

Создайте папку templates и внутри нее файлы index.html и quote.html.

index.html

html
<!DOCTYPE html>
<html>
<head>
    <title>Select an Actor</title>
</head>
<body>
    <h1>Select an Actor</h1>
    <form method="post">
        <select name="actor">
            {% for actor in actors %}
            <option value="{{ actor[0] }}">{{ actor[1] }}</option>
            {% endfor %}
        </select>
        <input type="submit" value="Get Quote">
    </form>
</body>
</html>

quote.html

html
<!DOCTYPE html>
<html>
<head>
    <title>Quote</title>
</head>
<body>
    <h1>Quote</h1>
    <p>{{ quote }}</p>
    <a href="/">Choose another actor</a>
</body>
</html>

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

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

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

### app.py

from flask import Flask, render_template, request, g
import sqlite3

app = Flask(__name__)
DATABASE = 'quotes.db'

def get_db():
    db = getattr(g, '_database', None)
    if db is None:
        db = g._database = sqlite3.connect(DATABASE)
        db.row_factory = sqlite3.Row
    return db

@app.teardown_appcontext
def close_connection(exception):
    db = getattr(g, '_database', None)
    if db is not None:
        db.close()

def init_db():
    with app.app_context():
        db = get_db()
        with open('schema.sql', mode='r') as f:
            db.cursor().executescript(f.read())
        db.commit()

def add_sample_data():
    actors = [('Morgan Freeman',), ('Tom Hanks',)]
    quotes = [
        (1, "Get busy living, or get busy dying."),
        (2, "Life is like a box of chocolates, you never know what you're gonna get.")
    ]
    db = get_db()
    db.executemany('INSERT INTO actors (name) VALUES (?)', actors)
    db.executemany('INSERT INTO quotes (actor_id, quote) VALUES (?, ?)', quotes)
    db.commit()

@app.route('/')
def index():
    db = get_db()
    actors = db.execute('SELECT * FROM actors').fetchall()
    return render_template('index.html', actors=actors)

@app.route('/quote', methods=['POST'])
def quote():
    actor_id = request.form['actor']
    db = get_db()
    quote = db.execute('SELECT quote FROM quotes WHERE actor_id = ? ORDER BY RANDOM() LIMIT 1', (actor_id,)).fetchone()
    actor_name = db.execute('SELECT name FROM actors WHERE id = ?', (actor_id,)).fetchone()
    return render_template('quote.html', quote=quote['quote'] if quote else "No quotes found.", actor_name=actor_name['name'] if actor_name else "Unknown")

if __name__ == '__main__':
    with app.app_context():
        init_db()  # Инициализация базы данных
        add_sample_data()  # Добавление начальных данных
    app.run(debug=True)

### Шаблоны 👉 в следующем посте

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

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

Шаблоны:

### Шаг 1: Создание файла app.py 👉 смотрите предыдущий пост

### Шаг 2: Создание схемы базы данных в файле schema.sql

Создайте файл schema.sql в той же директории, что и app.py. Этот файл будет содержать SQL-команды для создания таблиц базы данных.

sql
DROP TABLE IF EXISTS actors;
DROP TABLE IF EXISTS quotes;

CREATE TABLE actors (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL
);

CREATE TABLE quotes (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    actor_id INTEGER,
    quote TEXT NOT NULL,
    FOREIGN KEY (actor_id) REFERENCES actors(id)
);

### Шаг 3: Создание шаблонов HTML

Создайте папку templates в той же директории, что и app.py, и добавьте в нее следующие файлы:

index.html

html
<!DOCTYPE html>
<html>
<head>
    <title>Select an Actor</title>
</head>
<body>
    <h1>Select an Actor</h1>
    <form method="post" action="/quote">
        <select name="actor">
            {% for actor in actors %}
            <option value="{{ actor['id'] }}">{{ actor['name'] }}</option>
            {% endfor %}
        </select>
        <input type="submit" value="Get Quote">
    </form>
</body>
</html>

quote.html

html
<!DOCTYPE html>
<html>
<head>
    <title>Quote</title>
</head>
<body>
    <h1>Quote</h1>
    <p>{{ quote }}</p>
    <a href="/">Choose another actor</a>
</body>
</html>

### Запуск программы

Перед первым запуском убедитесь, что вы вызвали init_db() для инициализации базы данных. После первого запуска вы можете закомментировать эту строку, чтобы предотвратить повторное создание таблиц. Если вы хотите добавить в базу данных начальные данные, раскомментируйте add_sample_data()

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