Анализ данных (Data analysis)
Data science, наука о данных. @haarrp - админ РКН: clck.ru/3FmyAp
Show more📈 Analytical overview of Telegram channel Анализ данных (Data analysis)
Channel Анализ данных (Data analysis) (@data_analysis_ml) in the Russian language segment is an active participant. Currently, the community unites 50 256 subscribers, ranking 2 657 in the Technologies & Applications category and 12 484 in the Russia region.
📊 Audience metrics and dynamics
Since its creation on невідомо, the project has demonstrated rapid growth, gathering an audience of 50 256 subscribers.
According to the latest data from 25 June, 2026, the channel demonstrates stable activity. Although there has been a change in the number of participants by 38 over the last 30 days and by 0 over the last 24 hours, overall reach remains high.
- Verification status: Not verified
- Engagement rate (ER): The average audience engagement rate is 8.85%. Within the first 24 hours after publication, content typically collects 6.52% reactions from the total number of subscribers.
- Post reach: On average, each post receives 4 447 views. Within the first day, a publication typically gains 3 278 views.
- Reactions and interaction: The audience actively supports content: the average number of reactions per post is 28.
- Thematic interests: Content is focused on key topics such as llm, контекст, openai, архитектура, deepseek.
📝 Description and content policy
The author describes the resource as a platform for expressing subjective opinions:
“Data science, наука о данных.
@haarrp - админ
РКН: clck.ru/3FmyAp”
Thanks to the high frequency of updates (latest data received on 26 June, 2026), the channel maintains relevance and a high level of publication reach. Analytics show that the audience actively interacts with content, making it an important point of influence in the Technologies & Applications category.
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
Available now! Telegram Research 2025 — the year's key insights 
