Анализ данных (Data analysis)
Data science, наука о данных. @haarrp - админ РКН: clck.ru/3FmyAp
Mostrar más📈 Análisis del canal de Telegram Анализ данных (Data analysis)
El canal Анализ данных (Data analysis) (@data_analysis_ml) en el segmento lingüístico de Ruso es un actor destacado. Actualmente la comunidad reúne a 50 256 suscriptores, ocupando la posición 2 657 en la categoría Tecnologías y Aplicaciones y el puesto 12 484 en la región Rusia.
📊 Métricas de audiencia y dinámica
Desde su creación el невідомо, el proyecto ha mostrado un crecimiento acelerado, reuniendo a 50 256 suscriptores.
Según los últimos datos del 25 junio, 2026, el canal mantiene una actividad estable. En los últimos 30 días la variación de miembros fue de 38, y en las últimas 24 horas de 0, conservando un alto alcance.
- Estado de verificación: No verificado
- Tasa de interacción (ER): El promedio de interacción de la audiencia es 8.85%. Durante las primeras 24 horas tras publicar, el contenido suele obtener 6.52% de reacciones respecto al total de suscriptores.
- Alcance de las publicaciones: Cada publicación recibe en promedio 4 447 visualizaciones. En el primer día suele acumular 3 278 visualizaciones.
- Reacciones e interacción: La audiencia responde de forma activa: el promedio de reacciones por publicación es 28.
- Intereses temáticos: El contenido se centra en temas clave como llm, контекст, openai, архитектура, deepseek.
📝 Descripción y política de contenido
El autor describe el recurso como un espacio para expresar opiniones subjetivas:
“Data science, наука о данных.
@haarrp - админ
РКН: clck.ru/3FmyAp”
Gracias a la alta frecuencia de actualizaciones (últimos datos recibidos el 26 junio, 2026), el canal mantiene la vigencia y un amplio alcance. La analítica demuestra que la audiencia interactúa activamente con el contenido, lo que lo convierte en un punto de referencia dentro de la categoría Tecnologías y Aplicaciones.
def populate_python(size:int)->list:
b = []
for i in range(size):
b.append(i)
return b
Запуск функции с size = 10 000 000 занял в среднем 765 мс на моей машине.
Ускорим этот процесс!
▪Numpy
import numpy as np
def populate_numpy(size:int)->np.ndarray:
b = np.empty((size),dtype=np.int64)
for i in range(size):
b[i] = i
return b
Запуск функции с тем же количеством элементов занял 964 мс.
▪Numba
from numba import njit, prange
@njit
def populate_numba(size:int)->np.ndarray:
b = np.empty((size),dtype=np.int64)
for i in prange(size):
b[i] = i
return b
Как мы видим, функция почти такая же. Просто добавил декоратор и prange (функция диапазона в numba, которая работает параллельно). На этот раз время вычислений составило всего 16 мс! Почти в 50 раз быстрее, чем на голом Python. Это впечатляющий результат.
▪Julia
Julia – еще один язык, который набирает обороты. Его цель – предложить почти такую же гибкость и понятный синтаксис, как у Python, но с высокой скоростью компиляции кода.
function populate_array(size::Int)::AbstractVector{Int64}
b = Vector{Int64}(undef,size)
Threads.@threads for i=1:size
b[i] = i
end
return b
end
В Julia нет проблем с GIL, поэтому потоки могут работать параллельно. Это заняло всего 12 мс.
▪Mojo
Mojo – это новый язык, находящийся в стадии активной разработки.
from Pointer import DTypePointer
from Random import rand, random_ui64
from DType import DType
from Range import range
from Functional import parallelize
import SIMD
struct Vect:
var data: DTypePointer[DType.uint64]
var rows: Int
fn __init__(inout self, rows: Int):
self.data = DTypePointer[DType.uint64].alloc(rows)
self.rows = rows
fn __del__(owned self):
self.data.free()
@always_inline
fn len(self)->UInt64:
return self.rows
fn zero(inout self):
memset_zero(self.data, self.rows)
@always_inline
fn __getitem__(self, x: Int) -> UInt64:
return self.data.load(x)
@always_inline
fn __setitem__(self, x: Int, val: UInt64):
return self.data.store( x, val)
fn populate_mojo(b:Vect):
@parameter
fn process_row(i:Int):
b[i] = i
parallelize[process_row](b.rows)
Приведенная выше функция отработала всего за 7 мс, в 110 раз быстрее, чем Python, и намного быстрее, чем Julia. Это Python со скоростью света!
📌 Почитать про Mojo
@data_analysis_mlimport re
expr = 'i love Data Science'
pattern = 'love'
print(re.search(pattern, expr))
<re.Match object; span=(2, 6), match='love'>
Обратите внимание, что функция search находит только первый попавшийся шаблон, дальше она уже не смотрит:
expr = 'I love data science, i love @data_analysis_ml' print( re.search(pattern, expr))
<re.Match object; span=(2, 6), match='love'>
Нельзя забывать, что шаблон представляет собой последовательность символов, а не сами слова.
Например, как можно найти последовательность "love" в составном слове в Python, показано ниже.
>>> expr = 'So many lovers
>>> re.search('love', expr)
Как найти все вхождения при помощи findall и finditer.
В отличие от функции search, две другие функции findall и finditer найдут все вхождения. Разница между findall и finditer заключается в том, что первый возвращает список (list), а второй возвращает итератор (iterator), который мы обсудили ранее.
Возвращаясь к предыдущему примеру, регулярное выражение для обнаружения всех вхождений в Python будет иметь следующий вид:
expr = 'I love data science, I love @data_analysis_ml'
re.findall('love', expr)
['love', 'love']
re.finditer('love', expr)
<callable_iterator object at 0x7efd1caf6b60>
Проверяем начало строки с помощью функции match.
Функция match проверяет начало строки на соответствие шаблону.
Пример выше не начинается с "love", поэтому эта функция вернет значение None. С другой стороны, если выражение начинается с шаблона, функция match вернет объект Match. Рассмотрите следующие регулярные выражения в Python:
expr = 'i love Data Science'
re.match('Data', expr)
None
re.match('love', expr) is None
True
Исключаем шаблон из строки с sub
Ещё одной полезной функцией Python-модуля re является sub. Она необходима, когда один шаблон нужно заменить на другой и пригодится для подготовки текстов перед применением NLP-методов в Python, например, для избавления от всех цифр, знаков препинания и символов. К сигнатуре этой функции добавляется аргумент repl — на какую строку заменяем. Ниже регулярные выражения в Python это демонстрируют. Обратите внимание, что sub возвращает строку, поэтому их стоит переприсвоить.
expr = 'i love Data Science'
pattern = 'love'
repl = 'hate'
re.sub(pattern, repl, expr)
'i hate Data Science'
Также отметим, что функция заменяет все вхождения. Если требуется ограничить это число, то оно указывается в аргументе count.
re.sub(pattern, repl, expr, count=1)
▪шпаргалка по регулярным выражениям
@data_analysis_ml
import pandas as pd
import multiprocessing as mp
def your_datarame_func(df):
...
n_cores = max(mp.cpu_count() - 1, 1)
p = mp.Pool(n_cores) # Data parallelism Object
def parallelize_dataframe(df, func, n_cores):
df_split = np.array_split(df, n_cores)
df = pd.concat( pool.map(func, df_split) )
pool.close() ; pool.join()
return df
df_results = parallelize_dataframe(df, func=your_datarame_func)
Более высокоуровневый интерфейс предоставляет другой пакет из стандартной библиотеки — concurrent.futures, однако возможностей у него меньше. Он предоставляет 2 аналогичных API для работы с процессами и тредами — ProcessPoolExecutor и ThreadPoolExecutor.
import psutil
import pandas as pd
import numpy as np
from concurrent.futures import ProcessPoolExecutor, as_completed
def your_datarame_func(df):
...
num_procs = max(psutil.cpu_count(logical=True) - 1, 1)
splitted_df = np.array_split(df, num_procs)
df_results = []
with ProcessPoolExecutor(max_workers=num_procs) as executor:
results = [executor.submit(your_datarame_func, df=df) for df in splitted_df]
for result in as_completed(results):
try:
df_results.append(result.result())
except Exception as ex:
print(str(ex))
pass
df_results = pd.concat(df_results)
В concurrent.futures можно получить pid порождаемых процессов (пример). Также, можно использовать сторонние пакеты для параллельных вычислений.
▪ Часть 1
@data_analysis_mldf['col'].str.contains('pat') и df['col'].dt.days.
Ниже сравнение времени работы методов выше для операции добавления столбца-логарифма. Результаты ошеломляющие, векторизация быстрее циклов и iterrows в тысячу раз! Похожее сравнение можно прочитать тут.
import numpy as np
import pandas as pd
import math
df = pd.DataFrame(data={'values':range(1,100_000)})
temp=[]
# -------------------------------------------------
# 1.15 секунды
for idx in range(0, df.shape[0], 1):
temp.append(math.log(df['values'].iloc[idx]))
# 7.18 секунд
for i,row in df.iterrows():
temp.append(math.log(row['values']))
# 156 миллисекунд
for row in df.itertuples():
temp.append(math.log(row.values))
# 84.6 миллисекунды
temp = df['values'].apply(lambda x: math.log(x))
# 3.38 миллисекунды
temp = np.log(df['values'])
# -------------------------------------------------
df['new_values'] = temp
@data_analysis_ml
¡Ya disponible! Investigación de Telegram 2025 — los principales insights del año 
