Еще пример работы со звуком на Python может включать анализ звука, например, вычисление и визуализацию спектрограммы звукового сигнала. Для этого мы будем использовать библиотеки numpy, scipy и matplotlib.

Установите необходимые библиотеки, если они еще не установлены:

pip install numpy scipy matplotlib

Пример кода:

python
import numpy as np
from scipy.io.wavfile import read
from scipy.signal import spectrogram
import matplotlib.pyplot as plt

# Чтение WAV файла
fs, data = read('output.wav')

# Если аудио стерео (2 канала), преобразуем его в моно (1 канал)
if len(data.shape) > 1:
    data = np.mean(data, axis=1)

# Вычисление спектрограммы
freqs, times, Sx = spectrogram(data, fs=fs, nperseg=1024, noverlap=512, window='hann', scaling='spectrum')

# Построение спектрограммы
plt.figure(figsize=(10, 5))
plt.pcolormesh(times, freqs / 1000, 10 * np.log10(Sx), cmap='viridis')
plt.colorbar(label='Intensity [dB]')
plt.ylabel('Frequency [kHz]')
plt.xlabel('Time [s]')
plt.show()

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

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

Ещё один интересный пример работы со звуком на Python - это изменение скорости воспроизведения аудиозаписи без изменения её тональности. Для этой задачи мы воспользуемся библиотекой pydub и pydub.silence для выделения и изменения скорости воспроизведения немых участков.

Установите pydub, если она еще не установлена:

shell
pip install pydub

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

python
from pydub import AudioSegment
from pydub.playback import play
from pydub.silence import split_on_silence

# Загрузим аудиофайл
audio = AudioSegment.from_file("output.wav")

# Разобьем аудиофайл на участки без звука
chunks = split_on_silence(audio, 
    # настройка: участки звука короче 500 мс считаются тишиной
    min_silence_len = 500,

    # настройка: участки звука тише -36 дБФС считаются тишиной
    silence_thresh = -36
)

# Увеличим скорость каждого участка в два раза и соберем обратно в единое аудио
speed_up_audio = AudioSegment.empty()
for chunk in chunks:
    speed_up_audio += chunk.speedup(playback_speed=2.0)

# Воспроизведем ускоренное аудио
play(speed_up_audio)

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

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

В качестве следующего примера мы можем создать простое приложение, которое использует спектральный анализ для определения основной частоты (тона) звукового сигнала в реальном времени. Для этого нам понадобится библиотека PyAudio для записи аудио, а также NumPy и SciPy для обработки сигнала.

python
import pyaudio
import numpy as np
from scipy.fftpack import fft

CHUNK = 1024  # Размер блока
WIDTH = 2  # Ширина (в байтах)
CHANNELS = 1  # Моно
RATE = 44100  # Частота дискретизации (Гц)

p = pyaudio.PyAudio()

stream = p.open(format=p.get_format_from_width(WIDTH),
                channels=CHANNELS,
                rate=RATE,
                input=True,
                output=True,
                frames_per_buffer=CHUNK)

print("* recording")

while True:
    data = np.frombuffer(stream.read(CHUNK), dtype=np.int16)
    yf = fft(data)
    xf = np.linspace(0.0, 1.0/(2.0*1/RATE), CHUNK//2)
    freq = xf[np.argmax(2.0/CHUNK * np.abs(yf[0:CHUNK//2]))]
    print(f"Частота: {freq} Hz")

print("* done")

stream.stop_stream()
stream.close()

p.terminate()

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

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

shell
pip install pyaudio

Но в зависимости от вашей операционной системы установка PyAudio может потребовать дополнительных шагов.

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

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

Сначала установите Astropy и photutils, если у вас их еще нет:

shell
pip install astropy photutils

Вот базовый пример того, как можно использовать photutils для поиска звезд на изображении:

python
import numpy as np
from astropy.io import fits
from astropy.stats import mad_std
from photutils import DAOStarFinder
import matplotlib.pyplot as plt

# Открыть FITS файл
image_file = 'example.fits'  # замените на ваш файл
image_data = fits.getdata(image_file)

# Вычислить медианное абсолютное отклонение (MAD) в качестве оценки шума
bkg_sigma = mad_std(image_data)

# Инициализировать "звездоискатель" (star finder)
daofind = DAOStarFinder(fwhm=3., threshold=5.*bkg_sigma)

# Найти звезды
sources = daofind(image_data)

# Вывести количество найденных звезд
print(f"Найдено {len(sources)} звезд")

# Визуализировать изображение и найденные звезды
plt.imshow(image_data, cmap='gray_r', origin='lower')
plt.scatter(sources['xcentroid'], sources['ycentroid'], s=30, color='red', alpha=0.9)
plt.show()

В этом примере сначала считывается FITS-файл (стандартный формат для астрономических данных). Затем находится оценка шума на изображении. Инициализируется "звездоискатель" DAOStarFinder, который затем применяется к данным для поиска звезд. Результаты визуализируются с помощью Matplotlib.

Помните, что параметры DAOStarFinder, такие как fwhm и threshold, могут потребовать настройки в зависимости от ваших данных. В этом примере используется fwhm (ширина на полувысоте) 3 пикселя и пороговое значение 5 сигма.

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

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

Если вы хотите автоматически обнаруживать галактики на астрономических изображениях, вы можете использовать глубокое обучение, и в частности сверточные нейронные сети (CNN). Однако это требует обучающего набора данных, содержащего изображения с метками, указывающими на галактики. Один из способов создания такой модели описан ниже:

В этом примере используется библиотека Keras, поэтому сначала установите ее, если еще не сделали этого:

shell
pip install keras tensorflow

Код обучения модели будет выглядеть примерно так:

python
import keras
from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

# Создаем модель
model = Sequential()

# Добавляем сверточные слои
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(64, 64, 3)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

# Добавляем полносвязные слои
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

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

# Обучаем модель
model.fit(X_train, y_train, epochs=10, batch_size=32, validation_data=(X_test, y_test))

Этот пример предполагает, что вы уже загрузили и предобработали свои данные в массивы X_train, X_test, y_train и y_test.

После обучения модели можно использовать ее для предсказания объектов на новых изображениях:

python
new_image = ...  # Загрузите новое изображение и выполните те же предварительные обработки
prediction = model.predict(new_image)

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

Кроме того, это предполагает, что у вас есть доступ к большому количеству обучающих данных. Если у вас нет большого набора данных для обучения, возможно, вам придется использовать техники, такие как перенос обучения (transfer learning), где вы можете использовать предварительно обученную модель и адаптировать ее к своей задаче.

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

Ещё одной полезной библиотекой Python для астрономии является astroquery. Она позволяет получать данные от множества веб-служб и баз данных, таких как NASA Exoplanet Archive, SIMBAD, VizieR и других.

Вот пример того, как можно использовать astroquery для поиска информации о конкретной звезде:

python
from astroquery.simbad import Simbad

# Создаем объект запроса
customSimbad = Simbad()

# Добавляем поля для поиска
customSimbad.add_votable_fields('flux(V)', 'otype')

# Ищем информацию о звезде Betelgeuse
result_table = customSimbad.query_object("Betelgeuse")

# Выводим результат
print(result_table)

Этот код делает запрос к SIMBAD для поиска информации о звезде Betelgeuse. Результатом является таблица данных, включающая различную информацию о звезде.

Установите astroquery, если она еще не установлена:

shell
pip install astroquery

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

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

Библиотека Skyfield является современным модулем Python для высокоточной астрономической работы, который предоставляет доступ к широкому набору астрономических данных и позволяет вычислять позиции небесных тел с высокой точностью.

Вот пример того, как можно использовать Skyfield для определения времени восхода и захода Солнца для конкретного места:

python
from skyfield.api import Topos, load

# Загружаем ephemeris
ts = load.timescale()
planets = load('de421.bsp')

# Используем город San Francisco в качестве примера
san_francisco = Topos('37.7749 N', '122.4194 W')

# Вычисляем восход и заход Солнца для 14 июля 2023 года
t0 = ts.utc(2023, 7, 14)
t1 = ts.utc(2023, 7, 15)
f = planets['sun'].rise_and_set(san_francisco)
t, y = almanac.find_discrete(t0, t1, f)

for ti, yi in zip(t, y):
    print(ti.utc_strftime('%Y %b %d %H:%M:%S'), 'Rise' if yi else 'Set')

Этот код сначала загружает эфемериды (таблицы положений небесных тел) и определяет координаты Сан-Франциско. Затем он вычисляет времена восхода и захода Солнца для 14 июля 2023 года.

Установите Skyfield, если она еще не установлена:

shell
pip install skyfield

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

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

Для анализа спектральных данных в астрофизике можно использовать пакет specutils от Astropy. Он предоставляет базовые инструменты для работы со спектральными данными в различных форматах.

Пример использования specutils для загрузки и анализа спектра звезды:

python
from astropy import units as u
from specutils import Spectrum1D
from specutils.fitting import fit_generic_continuum
from specutils.manipulation import SplineInterpolatedResampler

# Загрузка данных спектра
flux = ...  # Загрузка данных о потоке
wavelength = ...  # Загрузка данных о длине волны
spectrum = Spectrum1D(flux=flux * u.Jy, spectral_axis=wavelength * u.AA)

# Применение continuum fitting (аппроксимация спектра с помощью функции)
g_fit = fit_generic_continuum(spectrum)
y_continuum_fitted = g_fit(wavelength)

# Произвести ресемплирование спектра с использованием сплайн-интерполяции
new_disp_grid = np.arange(3500, 8000, 5) * u.AA  # Новая сетка длин волн
resampler = SplineInterpolatedResampler()
resampled_spectrum = resampler(spectrum, new_disp_grid)

# Визуализация
plt.figure(figsize=(10, 6))
plt.plot(wavelength, flux, label='Original Spectrum')
plt.plot(new_disp_grid, resampled_spectrum.flux, label='Resampled Spectrum')
plt.plot(wavelength, y_continuum_fitted(wavelength), label='Continuum Fit')
plt.xlabel('Wavelength (Angstrom)')
plt.ylabel('Flux (Jy)')
plt.legend()
plt.show()

Этот код загружает спектральные данные (поток и длину волны), выполняет аппроксимацию спектра с помощью continuum fitting и производит ресемплирование с использованием сплайн-интерполяции. Результаты затем визуализируются с использованием Matplotlib.

Установите specutils, если она еще не установлена:

shell
pip install specutils

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

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

Самый короткий курс по Python для новичков - все что нужно и ничего лишнего 🤖

Переходи 👉 https://kodduu.ru/?p=149 🤖

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

Пример того, как можно использовать astropy для преобразования координат звезды:

python
from astropy import units as u
from astropy.coordinates import SkyCoord

# Укажем координаты Betelgeuse в системе координат RA/Dec
betelgeuse = SkyCoord.from_name('Betelgeuse')

# Теперь мы можем получить координаты Betelgeuse в других системах координат
print("Betelgeuse in Galactic coordinates: ", betelgeuse.galactic)
print("Betelgeuse in Alt/Az coordinates: ", betelgeuse.transform_to('altaz'))

В этом примере мы задаем координаты звезды Betelgeuse в радиальной системе координат (RA/Dec). Затем мы преобразуем эти координаты в галактическую систему координат и в систему координат Alt/Az.

Установите astropy, если она еще не установлена:

shell
pip install astropy

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

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

Давайте создадим программу, которая будет искать файлы в заданной директории по определенному шаблону с использованием модулей os и fnmatch:

python
import os
import fnmatch

def find_files(directory, pattern):
    for root, dirs, files in os.walk(directory):
        for basename in files:
            if fnmatch.fnmatch(basename, pattern):
                filename = os.path.join(root, basename)
                print(filename)

# Используйте любую директорию, которую вы хотите просканировать
directory = '/path/to/your/directory'
# Ищем все текстовые файлы
pattern = '*.txt'
find_files(directory, pattern)

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

Пожалуйста, замените '/path/to/your/directory' на путь к директории, которую вы хотите просканировать.

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

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

python
import requests

def download_image(url, file_name):
    response = requests.get(url, stream=True)
    response.raise_for_status()

    with open(file_name, 'wb') as file:
        for chunk in response.iter_content(8192):
            file.write(chunk)

# Ссылка на изображение
url = "https://www.example.com/image.jpg"
# Имя файла, куда будет сохранено изображение
file_name = "downloaded_image.jpg"
download_image(url, file_name)

В этом коде функция download_image загружает изображение по заданному URL и сохраняет его в файл. Мы используем requests.get с параметром stream=True, чтобы скачивать файл по частям, а не загружать его полностью в память сразу.

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

bash
pip install requests

Замените "https://www.example.com/image.jpg" на URL изображения, которое вы хотите загрузить, и "downloaded_image.jpg" на имя файла, под которым вы хотите сохранить изображение.

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

Liquibase - это инструмент для управления версиями баз данных. Он обычно используется через командную строку или встраивается в проект на Java. На Python прямой поддержки Liquibase нет, но можно использовать его через системные вызовы или shell команды. Вот пример того, как это можно сделать:

python
import subprocess

def run_liquibase(command):
    try:
        liquibase_path = "/path/to/liquibase"  # замените на реальный путь к Liquibase
        subprocess.check_call(f"{liquibase_path} {command}", shell=True)
    except subprocess.CalledProcessError as e:
        print(f"Ошибка при выполнении команды liquibase: {e}")
        raise

# Подготовка команды Liquibase для выполнения миграции
command = "update"

# Вызов функции с командой Liquibase
run_liquibase(command)

В этом примере мы вызываем Liquibase с командой update через вызов системной команды с использованием модуля subprocess. Это будет работать, если у вас установлен и настроен Liquibase и вы указали правильный путь к исполняемому файлу Liquibase в liquibase_path.

Пожалуйста, учтите, что для выполнения миграции Liquibase потребуется файл с описанием изменений базы данных (changelog), обычно это файлы форматов xml, json, yaml или sql.

Использование Liquibase через Python представляет собой простой вызов его команд, и поэтому может быть ограничено по сравнению с использованием Liquibase напрямую или через интеграцию с Java.

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

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

1. SQLite

SQLite - это встроенная база данных, поставляемая с Python. Ниже приведен пример кода для работы с SQLite:

python
import sqlite3
from sqlite3 import Error

def create_connection():
    conn = None;
    try:
        conn = sqlite3.connect(':memory:') # создаем базу данных в памяти
        print(sqlite3.version)
    except Error as e:
        print(e)

    if conn:
        conn.close()

if __name__ == '__main__':
    create_connection()

2. PostgreSQL

Для работы с PostgreSQL в Python обычно используется библиотека psycopg2. Ниже приведен пример кода:

python
import psycopg2
from psycopg2 import OperationalError

def create_conn():
    conn = None;
    try:
        conn = psycopg2.connect(
            database="your_database",
            user="your_username",
            password="your_password",
            host="127.0.0.1",
            port="5432",
        )
        print("Connection to PostgreSQL DB successful")
    except OperationalError as e:
        print(f"The error '{e}' occurred")
    return conn

if __name__ == '__main__':
    create_conn()

3. MySQL

Для работы с MySQL в Python обычно используется библиотека PyMySQL. Ниже приведен пример кода:

python
import pymysql.cursors

def create_conn():
    conn = None;
    try:
        conn = pymysql.connect(host='localhost',
                             user='user',
                             password='passwd',
                             db='db',
                             charset='utf8mb4',
                             cursorclass=pymysql.cursors.DictCursor)
        print("Connection to MySQL DB successful")
    except Exception as e:
        print(f"The error '{e}' occurred")
    return conn

if __name__ == '__main__':
    create_conn()

Помните, что вам нужно заменить "your_database", "your_username", "your_password", "localhost", "user", "passwd" и "db" на актуальные значения, которые вы используете для своей базы данных.

Обратите внимание, что эти примеры кода просто устанавливают соединение с базой данных и затем его закрывают. Для выполнения SQL-запросов вам потребуется использовать курсоры и методы execute / fetch.

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

Парсинг telegram канала

Сначала вам нужно установить пакет telethon. Вам может потребоваться pip3 вместо pip, в зависимости от вашего окружения Python:

pip install telethon

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

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

В приведенном ниже примере кода мы ищем ключевое слово "python" в сообщениях.

python
from telethon import TelegramClient, sync
from telethon.tl.functions.messages import GetHistoryRequest

api_id = 'YOUR_API_ID' 
api_hash = 'YOUR_API_HASH'
phone = 'YOUR_PHONE'

client = TelegramClient(phone, api_id, api_hash)

async def main():
    # Getting information about yourself
    me = await client.get_me()

    # "me" now contains the current user object. You can pretty-print
    # any Telegram object with the "stringify" method:

    print(me.stringify())

    # When you print something, you see a representation of it.
    # You can access all attributes of Telegram objects with
    # the dot operator. For example, to get the username, use "me.username".
    print(me.username)

    # You can print all the dialogs/conversations that you are part of:
    async for dialog in client.iter_dialogs():
        print(dialog.name, 'has ID', dialog.id)

    # If you want to send a message to a chat by its exact name,
    # you can do so like this:
    channel = await client.get_entity('Telegram')
    await client.send_message(channel, 'Hello, Telegra!')

    # Getting message history
    channel = await client.get_entity('Channel Name')  # replace 'Channel Name' with the name of the channel
    posts = await client(GetHistoryRequest(
        peer=channel,
        limit=100,
        offset_date=None,
        offset_id=0,
        max_id=0,
        min_id=0,
        add_offset=0,
        hash=0))

    # Searching for keyword
    keyword = 'python'
    for message in posts.messages:
        if keyword in message.message:
            print(message.id, message.message)

with client:
    client.loop.run_until_complete(main())

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

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

Помните, что в соответствии с политикой конфиденциальности Telegram, содержание сообщений доступно только при наличии соответствующих разрешений.

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

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

Следующий код ищет каждое слово из списка keywords и увеличивает счетчик каждый раз, когда это слово встречается в сообщении:

python
from telethon import TelegramClient, sync
from telethon.tl.functions.messages import GetHistoryRequest

api_id = 'YOUR_API_ID' 
api_hash = 'YOUR_API_HASH'
phone = 'YOUR_PHONE'

client = TelegramClient(phone, api_id, api_hash)

async def main():
    # Getting information about yourself
    me = await client.get_me()

    # You can print all the dialogs/conversations that you are part of:
    async for dialog in client.iter_dialogs():
        print(dialog.name, 'has ID', dialog.id)

    # Getting message history
    channel = await client.get_entity('Channel Name')  # replace 'Channel Name' with the name of the channel
    posts = await client(GetHistoryRequest(
        peer=channel,
        limit=100,
        offset_date=None,
        offset_id=0,
        max_id=0,
        min_id=0,
        add_offset=0,
        hash=0))

    # Defining keywords and initializing counter
    keywords = ['python', 'telegram', 'API']  # replace these with your keywords
    keywords_counter = {keyword: 0 for keyword in keywords}

    # Counting keywords
    for message in posts.messages:
        if message.message:
            for keyword in keywords:
                if keyword in message.message:
                    keywords_counter[keyword] += 1

    # Printing results
    for keyword, count in keywords_counter.items():
        print(f'Keyword "{keyword}" found {count} times')

with client:
    client.loop.run_until_complete(main())

Обратите внимание, что этот код ищет слова в точном соответствии с тем, как они написаны в списке keywords. Поиск регистрозависимый, что означает, что слова "python" и "Python" будут считаться разными словами. Если вы хотите игнорировать регистр, можно преобразовать сообщение и ключевые слова в нижний регистр перед проверкой вхождения.

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

Генерация word cloud по словам в сообщениях telegram канала

Сначала вам нужно установить пакеты wordcloud и matplotlib. Вам может потребоваться pip3 вместо pip, в зависимости от вашего окружения Python:

pip install wordcloud matplotlib

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

python
from telethon import TelegramClient, sync
from telethon.tl.functions.messages import GetHistoryRequest
from collections import Counter
from wordcloud import WordCloud
import matplotlib.pyplot as plt
import re

api_id = 'YOUR_API_ID' 
api_hash = 'YOUR_API_HASH'
phone = 'YOUR_PHONE'

client = TelegramClient(phone, api_id, api_hash)

async def main():
    # Getting information about yourself
    me = await client.get_me()

    # You can print all the dialogs/conversations that you are part of:
    async for dialog in client.iter_dialogs():
        print(dialog.name, 'has ID', dialog.id)

    # Getting message history
    channel = await client.get_entity('Channel Name')  # replace 'Channel Name' with the name of the channel
    posts = await client(GetHistoryRequest(
        peer=channel,
        limit=100,
        offset_date=None,
        offset_id=0,
        max_id=0,
        min_id=0,
        add_offset=0,
        hash=0))

    word_counter = Counter()
    
    # Counting keywords
    for message in posts.messages:
        if message.message:
            # Convert the message to lower case, remove non-alphabetic characters
            clean_message = re.sub('[^a-zа-я]+', ' ', message.message.lower())
            words = clean_message.split()
            word_counter.update(words)

    # Printing results
    for word, count in word_counter.most_common(10):
        print(f'Word "{word}" found {count} times')

    # Create a Word Cloud
    wc = WordCloud(width=800, height=400, max_words=200, background_color='white').generate_from_frequencies(word_counter)

    plt.figure(figsize=(10, 5))
    plt.imshow(wc, interpolation='bilinear')
    plt.axis('off')
    plt.show()

with client:
    client.loop.run_until_complete(main())

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

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

Создание игрового движка с нуля требует большого количества усилий, даже для относительно простой игры, такой как Wolfenstein 3D. Тем не менее, мы можем построить простой движок с использованием техники raycasting на Python, который будет имитировать основное поведение Wolfenstein 3D.

В этой реализации мы будем использовать Pygame, набор модулей Python, предназначенных для создания видеоигр. Этот пример создает базовую 2D карту, по которой вы можете перемещаться. Создание полной 3D среды с искусственным интеллектом противников, звуками или детализированными текстурами потребует более продвинутого программирования.

Если вы еще не установили pygame, вы можете сделать это с помощью pip:

pip install pygame

Ниже представлена простая реализация движка с использованием техники raycasting:

python
import pygame
import math

# Screen dimensions
WIDTH, HEIGHT = 640, 480

# Player parameters
player_pos = [WIDTH // 2, HEIGHT // 2]
player_angle = 0
player_speed = 3

# Map parameters
map = [
    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
    [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
    [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
    [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
    [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
    [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
    [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
    [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
    [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
]
map_size = 64
map_dim = (len(map[0]), len(map))

pygame.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))

def cast_ray(angle):
    dist = 0
    ray_pos = list(player_pos)
    d = [math.cos(angle), math.sin(angle)]
    while dist < WIDTH:
        ray_pos[0] += d[0]
        ray_pos[1] += d[1]
        dist += 1
        map_pos = [int(ray_pos[0] // map_size), int(ray_pos[1] // map_size)]
        if map[map_pos[1]][map_pos[0]] == 1:
            return dist
    return dist

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            exit(0)

    # Update player
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT]:
        player_angle -= 0.05
    if keys[pygame.K_RIGHT]:
        player_angle += 0.05
    if keys[pygame.K_UP]:
        player_pos[0] += player_speed * math.cos(player_angle)
        player_pos[1] += player_speed * math.sin(player_angle)
    if keys[pygame.K_DOWN]:
        player_pos[0] -= player_speed * math.cos(player_angle)
        player_pos[1] -= player_speed * math.sin(player_angle)

    # Draw scene
    screen.fill((0, 0, 0))
    for x in range(WIDTH):
        angle = player_angle - math.pi / 6 + x / WIDTH * math.pi / 3
        dist = cast_ray(angle)
        h = HEIGHT / dist * 50
        pygame.draw.rect(screen, (255, 255, 255), (x, HEIGHT // 2 - h // 2, 1, h))

    pygame.display.flip()

Эта программа создает 10x10 карту со стенами по краям. Игрок может передвигаться и поворачиваться на этой карте. Алгоритм raycasting реализован в функции cast_ray, которая вычисляет расстояние до ближайшей стены для каждой колонки на экране.

Помните, что это упрощенная версия движка, похожего на Wolfenstein 3D. На стенах нет текстур, нет потолка или пола, нет объектов, нет врагов и т.д. Для создания полной игры, похожей на Wolfenstein 3D, потребуется намного больше кода. Вам придется добавить спрайты, текстуры, звук, игровую логику и многое другое.

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

Для добавления текстур на стены в игре с помощью Pygame, вам потребуется изображение текстуры. Загрузите изображение текстуры и сохраните его в той же директории, что и ваш скрипт Python. Допустим, имя вашего файла текстуры - texture.png.

python
import pygame
import math

# Screen dimensions
WIDTH, HEIGHT = 640, 480

# Player parameters
player_pos = [WIDTH // 2, HEIGHT // 2]
player_angle = 0
player_speed = 3

# Map parameters
map = [
    # your map array
]
map_size = 64
map_dim = (len(map[0]), len(map))

# Load the texture
texture = pygame.image.load("texture.png")

pygame.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))

def cast_ray(angle):
    # same as before

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            exit(0)

    # Update player
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT]:
        player_angle -= 0.05
    if keys[pygame.K_RIGHT]:
        player_angle += 0.05
    if keys[pygame.K_UP]:
        player_pos[0] += player_speed * math.cos(player_angle)
        player_pos[1] += player_speed * math.sin(player_angle)
    if keys[pygame.K_DOWN]:
        player_pos[0] -= player_speed * math.cos(player_angle)
        player_pos[1] -= player_speed * math.sin(player_angle)

    # Draw scene
    screen.fill((0, 0, 0))
    for x in range(WIDTH):
        angle = player_angle - math.pi / 6 + x / WIDTH * math.pi / 3
        dist = cast_ray(angle)
        h = HEIGHT / dist * 50
        h = int(h)
        
        # Calculate the texture position
        tx = int((angle - player_angle) / math.pi * 3 * texture.get_width())
        tx = max(0, min(tx, texture.get_width() - 1))
        
        # Draw the texture column
        for y in range(h):
            ty = y / h * texture.get_height()
            ty = int(ty)
            color = texture.get_at((tx, ty))
            screen.set_at((x, HEIGHT // 2 - h // 2 + y), color)

    pygame.display.flip()

Этот код загружает текстуру, вычисляет позицию каждого пикселя на текстуре и рисует колонку текстуры для каждой колонки на экране. Это создает эффект 3D стен.

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

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

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

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

Специальная теория относительности (СТО): временная дилатация из-за скорости. Время на быстро движущихся спутниках идет медленнее по сравнению со стационарным наблюдателем на Земле.

Общая теория относительности (ОТО): гравитационное сжатие времени. Время в гравитационном поле идет медленнее по сравнению с отсутствием гравитационного поля.

Код ниже не является полной реализацией GPS, но демонстрирует основные принципы его работы.

Примечание: этот код предназначен для иллюстративных целей и не предназначен для реального использования.

python
import numpy as np

# Constants
c = 3e8 # Speed of light in m/s
R = 6.4e6 # Radius of the Earth in m
H = 3.6e7 # Height of geostationary orbit in m
G = 6.67e-11 # Gravitational constant in m^3/kg/s^2
M = 5.97e24 # Mass of the Earth in kg

# Velocity of satellite
v = np.sqrt(G * M / (R + H))

# Time dilation due to special relativity
gamma = 1 / np.sqrt(1 - v**2 / c**2)

# Time dilation due to general relativity
g = G * M / (R + H)**2
alpha = np.sqrt(1 - 2 * g * (R + H) / c**2)

# Total time dilation
time_dilation = gamma / alpha

print("Total time dilation due to relativistic effects: ", time_dilation)

# Simulate sending a signal from the satellite to the ground
t0 = 0 # Time signal is sent
x_satellite = H + R # Position of satellite

# Time signal is received
t1 = t0 + x_satellite / c * time_dilation

print("Time signal is received: ", t1)

Сначала мы определяем скорость спутника на основе простого расчета круговой скорости, затем мы вычисляем дилатацию времени из-за СТО и ОТО.

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

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

Анализ последовательностей ДНК может означать множество вещей, включая выравнивание последовательностей, поиск открытых рамок чтения, анализ генома и так далее. В данном примере я покажу, как можно использовать Python и библиотеку Biopython для поиска открытых рамок чтения (ORF) в последовательности ДНК.

Открытая рамка чтения - это участок в ДНК, который потенциально может быть прочитан и переведен в белок.

python
from Bio.Seq import Seq
from Bio.Alphabet import generic_dna

def find_orfs(dna_sequence, start_codons, stop_codons):
    orfs = []
    start_positions = []
    
    # Find start codons
    for i in range(len(dna_sequence)):
        if dna_sequence[i:i+3] in start_codons:
            start_positions.append(i)
            
    # Find open reading frames
    for start in start_positions:
        for i in range(start, len(dna_sequence), 3):
            if dna_sequence[i:i+3] in stop_codons:
                orfs.append(dna_sequence[start:i+3])
                break
                
    return orfs

# Test the function
dna_seq = Seq("ATGAGTCTTGACGTAGTAGTAGTAA", generic_dna)
start_codons = ["ATG"]
stop_codons = ["TAA", "TAG", "TGA"]

orfs = find_orfs(dna_seq, start_codons, stop_codons)

for i, orf in enumerate(orfs):
    print(f"ORF {i+1}: {orf}")

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

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

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