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

Для этого нам понадобится библиотека wordcloud, которую можно установить с помощью pip:

bash
pip install wordcloud

Теперь давайте сгенерируем облако слов на основе некоторого текста:

python
from wordcloud import WordCloud
import matplotlib.pyplot as plt

def generate_wordcloud(text):
    wordcloud = WordCloud(width = 800, height = 800, 
                          background_color ='white', 
                          stopwords = None, 
                          min_font_size = 10).generate(text)
    
    plt.figure(figsize = (8, 8), facecolor = None) 
    plt.imshow(wordcloud)
    plt.axis("off")
    plt.tight_layout(pad = 0)
      
    plt.show()

text = """
Python is an interpreted high-level general-purpose programming language. Python's design philosophy emphasizes code readability with its notable use of significant indentation. Its language constructs as well as its object-oriented approach aim to help programmers write clear, logical code for small and large-scale projects.
"""

generate_wordcloud(text)

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

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

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

Этот код создает небольшую текстовую RPG (ролевую игру), где пользователь должен выбирать свои действия.

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

    def attack(self, enemy):
        enemy.health -= self.power
        print(f"{self.name} attacks {enemy.name}!")

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

class Player(Character):
    def decision(self, enemy):
        decision = input("Do you want to [A]ttack, [H]eal, or [R]un away? ")
        if decision.upper() == "A":
            self.attack(enemy)
        elif decision.upper() == "H":
            self.health += 10
            print(f"{self.name} heals!")
        elif decision.upper() == "R":
            print(f"{self.name} runs away...")
            return False
        return True

class Enemy(Character):
    pass

def game():
    player = Player("Hero", 50, 10)
    enemy = Enemy("Enemy", 50, 5)

    while player.is_alive() and enemy.is_alive():
        print(f"{player.name} HP: {player.health}, {enemy.name} HP: {enemy.health}")
        if not player.decision(enemy):
            break
        if enemy.is_alive():
            enemy.attack(player)

game()

В этой игре вы играете за "Hero" и сражаетесь с "Enemy". Ваша цель - уничтожить врага, управляя своим персонажем: атакуйте врага, лечите себя или бегите, если ситуация становится слишком опасной.

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

Вот еще один интересный пример кода на Python. Этот код генерирует бесконечную последовательность чисел Фибоначчи.

python
def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

fib = fibonacci()

for _ in range(10):
    print(next(fib))

В этом коде используется концепция генераторов в Python. Функция fibonacci является бесконечным генератором, который продолжает возвращать числа Фибоначчи каждый раз, когда мы вызываем next(fib). Поскольку это бесконечный генератор, вы можете продолжать вызывать next(fib) сколько угодно раз, и он продолжит возвращать следующее число Фибоначчи.

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

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

Вот пример кода на Python, который записывает аудио с микрофона, сохраняет его в файл, а затем воспроизводит этот файл. Мы будем использовать библиотеку sounddevice для записи и воспроизведения звука, и библиотеку scipy для сохранения звуковых данных в файл.

Установите эти библиотеки, используя pip, если они у вас еще не установлены:

pip install sounddevice scipy

А вот пример кода:

python
import sounddevice as sd
from scipy.io.wavfile import write, read
import numpy as np

# Настройте длительность записи в секундах и частоту дискретизации
duration = 5.0  # seconds
fs = 44100  # Sampling frequency

# Запись звука
print("Начинаем запись")
recording = sd.rec(int(duration * fs), samplerate=fs, channels=2)
sd.wait()  # Wait until recording is finished
print("Запись завершена")

# Сохранение записи в файл
write('output.wav', fs, recording)

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

# Воспроизведение записанного звука
print("Воспроизведение записи")
sd.play(data, fs)
sd.wait()  # Wait until file is done playing
print("Воспроизведение завершено")

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

Обратите внимание: Этот код работает с устройствами ввода/вывода звука по умолчанию на вашей машине. Если у вас есть специфические требования к оборудованию, вам возможно придется добавить дополнительные параметры при вызове sd.rec и sd.play.

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

Еще пример работы со звуком на 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 🤖