У меня тут новая статья, в которой собраны некоторые соображения по поводу работы с Selenium и Python для скрейпинга, и о том, какие могут возникать сложности https://www.scrapingbee.com/blog/selenium-python/

Scrapingbee

Web Scraping Tutorial Using Selenium & Python (+ examples) | ScrapingBee

Lean how to scrape the web with Selenium and Python with this step by step tutorial. We will use Selenium to automate Hacker News login.

Первый урок по языку Go! Сегодня мы настроим рабочую среду, подготовим проект и напишем скрипт для конвертации чисел из шестнадцатеричного формата в десятичный. Параллельно обсудим несколько важных тем, включая типы данных, переменные, функции, больше числа и многое другое. https://www.youtube.com/watch?v=GvAM9FjKkY0

YouTube

Язык Go #1 | Установка, настройка, обработка ввода, конвертация чисел, big int

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

В этом видео мы поговорим о том, как работать с инструментом Gettext для перевода приложений. https://www.youtube.com/watch?v=fDzRhWc10b8

YouTube

Перевод приложений с Gettext | Установка, настройка, использование Gettext

В этом видео мы поговорим о том, как работать с инструментом Gettext для перевода приложений.Таймкоды:00:00 Введение00:30 Установка Gettext и подготовка прое...

Залетайте сегодня вечером https://www.youtube.com/live/Y9fQL13VeWo

YouTube

Solidity и Ethereum, урок #74 | Собеседование в 2024! Сложные вопросы

В этом уроке по Solidity мы отправляемся на собеседование, и это продолжение предыдущего урока. В этот раз будут сложные вопросы, которые были опубликованы в 2024 году. Список вопросов тут: https://www.rareskills.io/post/solidity-interview-questions Станьте…

Опять сегодня использовал chat gpt для проверки правописания, а потом немного поразвлекался. Вышло забавно. 😂

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

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

Пока я в "подходящем" состоянии, сгруппирую рекомендации последних месяцев.

Музыка:

- 1184 (Windir)
- Noble (Versailles)
- Ranarop (Gjallarhorn)
- Lec, eglīte (Skyforger) - это сингл

Игры:

Боюсь, что ничего. Кто-то спросит про baldur's gate, но мне совершенно не понравилось. Поиграли с Ailura, мне показалось скучновато, один я бы даже не стал пробовать

Книги:

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

Фильмы/анимация:

- Дюна 2
- Hotaru no Haka - трагедия, которая вновь чрезвычайно актуальна

Если в frac указано что-то иное (не все нули), то это значение называется "not a number" (NaN). Оно может вылезти, если результат невозможно представить реальными числами (настоящие джедаи помнят про мнимые числа, это не тот случай), либо если происходит что-то странное в духе "бесконечность минус бесконечность".

В качестве примера можно взять 8-битный формат, где на exp отводится k=4 бит, а на frac даётся n=3 бит (понятно, что на знак в любом случае 1 бит). В этом случае значение bias B = 2 ** (4\-1) \- 1 = 7.

Как мы представим ноль? Ну, очевидно вот так (биты разграничены по соответствующим полям):

0 0000 000

e=0, E = 1 \- 7 = \-6.

f можно записать как 0 / 8 (тк в поле frac у нас все нули), M = f = 0 / 8. Выходит формула:

((\-1) ** 0) * (0/8) * (2 ** \-6) = 0

Классно. Теперь число 7/8, то есть 0.875. Его представление:

0 0110 110

e = 0110 = 6, тогда E = 6 \- 7 = \-1.

Теперь f. У нас три бита, 2 ** 3 = 8, а само значение frac = 110, то есть 6. Выходит, что f = 6/8, M = 14 / 8.

Подставляем:

((\-1) ** 0) * (14 / 8) * (2 ** \-1) = 0.875

Попробуем ещё взять вот такое число, это в нашем случае самое большое из денормированных:

0 0000 111

Выходит, что e = 0, E = \-6. При этом f = M = 7/8. Подставим:

((\-1) ** 0) * (7/8) * (2 ** \-6) ~ 0.013671875

А если самое маленькое из нормированных?

0 0001 000

Тут e = 1, E = \-6, f = 0 / 8, M = 8 / 8. Подставляем:

((\-1) ** 0) * (8/8) * (2 ** \-6) ~ 0.015625

Аналогично, самое маленькое позитивное число, которое мы можем представить (грубо говоря, самое близкое к нулю):

0 0000 001

Тут e = 0, E = \-6, f = M = 1/8. В формуле:

((\-1) ** 0) * (1/8) * (2 ** \-6) = 0.001953125

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

Кстати, тут один интересный момент. Смотрите, что у нас вышло:

```
0 0000 000 = 0

0 0000 001 = 0.001953125

0 0000 111 = 0.013671875

0 0001 000 = 0.015625

0 0110 110 = 0.875
```

Я расположил эти числа по возрастанию от самого маленького десятичного к самому большому. Но при этом можно видеть, что их двоичные аналоги тоже стоят по возрастанию! Это вовсе не случайно: стандарт создавался с учётом того, что программистам наверняка потребуется сортировать такие числа по тем же принципам, что и для целых чисел (хотя тут есть небольшая проблема, если в первом бите появляется 1, то есть число отрицательное).

Собственно говоря, из примера выше мы видим, что представить "любое" число мы с помощью такого стандарта не можем. К примеру, у нас идёт "перескок" от 0.013671875 сразу к 0.015625, и сделать с этим особенно ничего не получится. Да, можно использовать не 8 бит, а 32 или даже 64 (двойная точность), но, как вы понимаете, всё равно покрыть все возможные случаи никак не выйдет. Поэтому в том же Rust есть понятие "эпсилон" (мы его с вами видели на стриме), то есть определённая погрешность, которую стоит учитывать.

Теперь поговорим о дробных числах и их представлении в компьютере, в частности, о том, как их описывает стандарт IEEE 754, принятый в 1985 году.

Чтобы было проще, начнём с обычного десятичного числа 35.42, у которого, как можно видеть, имеется дробная часть. Как ещё можно записать это число? Ну, к примеру, вот так:

3 * (10 ** 1) + 5 * (10 ** 0) + 4 * (10 ** \-1) + 2 * (10 ** \-2)

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

При этом цифрам, стоящим после точки, мы просто присваиваем отрицательные индексы. В принципе, это же число можно представить как 35 + (42 / 100), суть та же.

Ясное дело, этот принцип можно применить и двоичным числам. К примеру, если взять двоичное 101.11, то у нас выйдет:

1 * (2 ** 2) + 0 * (2 ** 1) + 1 * (2 ** 0) + 1 * (2 ** \-1) + 1 * (2 ** \-2)

Или, проще говоря,

4 + 0 + 1 + (1/2) + (1/4)

То есть мы видим, что после точки у нас появляются дроби со степенями двойки: 1/2, 1/4, 1/8, и так далее. Так мы можем легко представить дробь 3/16 (или 0.1875), это будет 0.0011. Хотя такой подход в теории можно использовать, он не слишком удобен, особенно для очень больших чисел.

Поэтому стандарт IEEE 754 представляет дробные числа в виде формулы:

((\-1) ** s) * M * (2 ** E)

Здесь три параметра, и в компьютере каждый хранится в своём поле.

s равно либо 0, либо 1. Это информация о знаке, соответствующее поле занимает всегда 1 бит.

M - это мантисса, дробное число, обычно меньше 1. Его представляет поле frac, занимает оно n бит и содержит последовательностьf(n\-1), ..., f(1), f(0).

Ну, а E - это экспонента, которая может быть как положительной, так и отрицательной. Её представляет поле exp длиной k бит с последовательностью e(k\-1), ..., e(1), e(0).

Итак, эти числа состоят аж из трёх полей сразу, и обычно имеют либо одинарную (single, 32 бита), либо двойную (double, 64 бита) точность. К примеру, для одинарной точности s занимает один бит номер 31, exp - с 23 по 30 биты, остальное (с 0 по 22) отводится под мантиссу.

Здесь, правда, возможно три разных случая.

Первый случай самый типичный, он описывает нормированные значения. Это случай, когда экспонента не состоит целиком из нулей или целиком из единиц. Говорят, что экспонента хранится в смещённой (biased) форме, а само её значение считается как:

E = e \- B

e - число без знака с последовательностью e(k\-1), ..., e(1), e(0). B - это значение bias, которое равно 2 ** (k \- 1) \- 1, то есть для одинарной точности оно равно 127, потому что в этом случае длина поля exp составляет 8 бит.

Следовательно, финальное значение E будет лежать в пределах от -126 (тк e - число без знака, и оно точно больше нуля в данном случае) до 127 для одинарной точности.

Поле frac в этом случае описывает дробную часть, то есть его значение f в десятичном виде лежит от 0 (включительно) до 1 (не включительно), это довольно важно, процесс формирования f увидим в примере ниже. Финальное значение мантиссы M = 1 + f.

Следующий случай - денормированные значения, это когда в поле exp содержатся все нули. В этом случае E = 1 \- B, M = f.

Такие денормированные значения, в частности, используются, чтобы представить значение 0. А чего бы нам для нуля не использовать первый случай? Ну потому, что там M = 1 + f, то есть в любом случае M >= 1.

Кстати, тут получается интересный момент: у нас может быть как +0, так и -0. Почему? Потому что хотя биты в exp и frac занулены, s всё равно может иметь значение как 0, так и 1.

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

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

Если в frac записаны одни нули, то таким образом мы представляем бесконечность (плюс или минус бесконечность, зависит от знака s) - примеру, если мы поделили на ноль.

Иными словами, нам нужно объяснить компьютеру, с чем мы имеем дело и как хотим интерпретировать этот вектор. Собственно говоря, именно поэтому нам нужно быть очень аккуратными, если мы конвертируем числа со знаком в числа без знака:

```
let number: i8 = -6;

println!("{number:b}");

let number2: u8 = number as u8;

println!("{number2}");
println!("{number2:b}");
```

Результат выполнения:

11111010 250 11111010

То есть последовательность битов та же, но интерпретация другая! Это происходит не только в Rust, но и в других языках, к примеру, в C.

С u8 ситуация может быть не сильно лучше:

```
let number: u8 = 255;

let number2: i8 = number as i8;

println!("{number2}");
```

На экран будет выведено \-1.

Из всего этого следует важный вывод: конвертировать числа таким образом стоит с большой осторожностью, потому что это может привести к неожиданным проблемам и серьёзным багам. Инструмент Clippy даже выдаст предупреждение на моменте number as i8. Если вам нужно просто "отбросить" знак, то следует использовать функцию "модуль" .abs().

В этом уроке мы рассмотрим новую структуру данных - граф (graph). Мы обсудим обычные, направленные и взвешенные графы и узнаем, зачем они нужны и как по ним реализовать поиск. Кроме того, напишем алгоритм Дийстры, с помощью которого можно легко найти наиболее оптимальный путь между несколькими точками. https://youtu.be/x-fOp6ulvF8

YouTube

Алгоритмы и структуры данных #7 | Graphs: графы, построение маршрутов, алгоритм Дийкстры

В этом уроке мы рассмотрим новую структуру данных - граф (graph). Мы обсудим обычные, направленные и взвешенные графы и узнаем, зачем они нужны и как по ним реализовать поиск. Кроме того, напишем алгоритм Дийстры, с помощью которого можно легко найти наиболее…