When you're doing a parser or migrating a site, there's often a pile of unreadable HTML markup on the screen. Converting this into neat Markdown is usually a hassle.

In the open code, I found a convenient tool called python-markdownify, which precisely solves the problem of converting HTML to Markdown.

The logic is simple: you take bulky HTML and get a clear and well-structured Markdown as a result.

The tool is easily customizable. You can clean up the necessary tags, change the format of headings, and neatly process tables and images. All of this can be configured.

It's installed via pip. It can be used both from Python code and from the command line, converting files in batches.

pip install python-markdownify

If desired, you can inherit and redefine the conversion rules for your own cases. The extensibility is fine there.

If you have to process large amounts of text or migrate a blog, the library saves a lot of time that would otherwise be spent on tedious work with regular expressions.

➡️ Link to GitHub
https://github.com/matthewwithanm/python-markdownify

#python #markdown #html #coding #devtools #opensource

✨ Join Best TG Channels https://t.iss.one/addlist/0f6vfFbEMdAwODBk

⭐️ Join Our WhatsApp Channel https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A

Limiting program resources using the resource module 🛡️

import resource
import sys

# 1. Limiting the size of RAM (soft and hard limits in bytes)
# Limit the memory to ~50 MB
memory_limit = 50 * 1024 * 1024 
resource.setrlimit(resource.RLIMIT_AS, (memory_limit, memory_limit))

# 2. Checking the protection's working
try:
    print("Trying to allocate a huge array of memory...")
    huge_list = [i for i in range(10_000_000)]
except MemoryError:
    print("The limit worked! The program didn't crash, but caught the error.")

# 3. Finding out how many resources the script has already consumed
usage = resource.getrusage(resource.RUSAGE_SELF)
print(f"Peak memory consumption (in KB): {usage.ru_maxrss}")

Protecting the server from "greedy" code 🔧

When you run someone else's code, process user files, or write parsers, there's always a risk of a memory leak or an infinite loop. If such a script runs on the server, it can fill up all the RAM and bring down neighboring important processes (for example, the database). The built-in resource module (works on Unix/Linux/macOS) allows you to strictly limit the program's appetites.

— Safe environment: You can limit not only RAM (RLIMIT_AS), but also CPU time (RLIMIT_CPU). If the code goes into an infinite loop, the system will gracefully terminate it after a specified number of seconds.

— File system control: Using RLIMIT_FSIZE, you can prevent the script from creating files larger than a certain size. This will save the server's disks from being accidentally overwritten by gigantic logs.

— Precise audit: The getrusage function provides detailed statistics on the current process: how much time the CPU spent on calculations, how many I/O operations there were, and what the maximum amount of memory used was during the entire operation.

#Python #ResourceManagement #ServerSafety #Coding #DevOps #Linux

✨ Join Best TG Channels https://t.iss.one/addlist/0f6vfFbEMdAwODBk

⭐️ Join Our WhatsApp Channel https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A

🚀 Level up your AI & Data Science skills with HelloEncyclo — a growing all-in-one platform featuring hands-on courses in LLMs, Deep Learning, MLOps, Data Engineering, and more.
✅ 13 courses live + 40+ coming soon
🎯 One access, lifetime updates
🔑 Use code: PRESALE-BOOK-WAVE-2GFG
👉 https://helloencyclo.com/?ref=HUSSEINSHEIKHO

Shuffling without repetitions:

import random

# Initial list of candidates or prizes
participants = ["Alexey", "Maria", "Ivan", "Olga", "Dmitry"]

# 1. Selecting 3 unique winners (sample without replacement)
winners = random.sample(participants, k=3)
print(f"Winners: {winners}") 
# The result is different each time, but there will be no repetitions within the list of winners!

# 2. Shuffling an entire string (creating an anagram)
word = "python"
shuffled_word = "".join(random.sample(word, len(word)))
print(f"Anagram: {shuffled_word}")

# 3. Important difference: random.choices allows repetitions
print(f"With repetitions: {random.choices(participants, k=3)}")

✨ Honest selection and generation of unique sets

When it's necessary to implement the logic of prize draws, random task distribution, or generating test questions, developers often use random.choice() in a loop. But this approach requires manually ensuring that the same element is not selected twice. The random.sample function takes on this routine.

— Guarantee of uniqueness: The main property of random.sample is "without replacement". The extracted element no longer participates in the next selection cycle, which completely eliminates duplicates in the resulting list.

— Safety of the original: The function does not modify the original list (unlike random.shuffle()), but creates a completely new array with the results. This allows the structure of the original data to remain intact.

— Strict control of size: If you pass a parameter k (the number of elements) that exceeds the length of the original list, Python will not start duplicating elements and will immediately throw an ValueError error. This protects the program logic from incorrect data.

#Python #Random #Coding #NoRepetition #DataScience #UniqueSets

✨ Join Best TG Channels https://t.iss.one/addlist/0f6vfFbEMdAwODBk

⭐️ Join Our WhatsApp Channel https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A

🚀 Level up your AI & Data Science skills with HelloEncyclo — a growing all-in-one platform featuring hands-on courses in LLMs, Deep Learning, MLOps, Data Engineering, and more.
✅ 13 courses live + 40+ coming soon
🎯 One access, lifetime updates
🔑 Use code: PRESALE-BOOK-WAVE-2GFG
👉 https://helloencyclo.com/?ref=HUSSEINSHEIKHO

How to create your own context manager in Python for opening and closing a connection to the SQLite database

The enter() method is used when opening a connection, and the exit() method is used when closing it:

import sqlite3

class DatabaseConnection:
    def __init__(self, db_name):
        self.db_name = db_name
        self.connection = None

    def __enter__(self):
        self.connection = sqlite3.connect(self.db_name)
        return self.connection

    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.connection:
            self.connection.close()

# Usage
with DatabaseConnection("example.db") as conn:
    cursor = conn.cursor()
    cursor.execute("SELECT * FROM users")

✨ Join Best TG Channels https://t.iss.one/addlist/0f6vfFbEMdAwODBk

⭐️ Join Our WhatsApp Channel https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A

🚀 Level up your AI & Data Science skills with HelloEncyclo — a growing all-in-one platform featuring hands-on courses in LLMs, Deep Learning, MLOps, Data Engineering, and more.
✅ 13 courses live + 40+ coming soon
🎯 One access, lifetime updates
🔑 Use code: PRESALE-BOOK-WAVE-2GFG
👉 https://helloencyclo.com/?ref=HUSSEINSHEIKHO

#Python #SQLite #ContextManager #Programming #Coding #Tech

Safe rounding of numbers with math.fsum

import math

# Initial list with fractions
values = [0.1] * 10

# 1. Regular summation via sum()
print(f"Standard sum(): {sum(values)}") # 0.9999999999999999

# 2. Exact summation via math.fsum()
print(f"Exact math.fsum(): {math.fsum(values)}") # 1.0

Eliminating errors when calculating arrays

We've already discussed why float in Python loses accuracy and how Decimal deals with this. But what if you need to add a million ordinary real numbers from a database or matrix, and it's not possible to convert everything to heavy Decimal objects due to a performance hit? The math.fsum() function comes to the rescue.

— Eliminating accumulated error: When sequentially adding elements via the standard sum(), the microscopic errors of float are rounded at each step and "accumulate" in the loop. The math.fsum() function tracks intermediate accuracy losses and compensates for them during the calculations.

— High performance: Since the math module is written in C, this function works several times faster than manually iterating through the array or using alternative data types. You get the speed of basic float calculations with near-perfect accuracy.

— Stability in Data Science: This tool is indispensable when working with weights in neural networks, calculating averages of large samples, or processing financial transactions, where speed is important but it's critical not to lose valuable cents and fractions during mass operations.

🐍 #Python #DataScience #Coding #Programming #MathFsum #TechTips

✨ Join Best TG Channels https://t.iss.one/addlist/0f6vfFbEMdAwODBk

⭐️ Join Our WhatsApp Channel https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A

🚀 Level up your AI & Data Science skills with HelloEncyclo — a growing all-in-one platform featuring hands-on courses in LLMs, Deep Learning, MLOps, Data Engineering, and more.
✅ 13 courses live + 40+ coming soon
🎯 One access, lifetime updates
🔑 Use code: PRESALE-BOOK-WAVE-2GFG
👉 https://helloencyclo.com/?ref=HUSSEINSHEIKHO

Catch a useful trick for working with division in Python 🐍

divmod() takes two numbers and in a single operation returns a tuple with the quotient and remainder from the division 📊

#Python #Coding #Programming #Tech #Tips #Dev

✨ Join Best TG Channels https://t.iss.one/addlist/0f6vfFbEMdAwODBk

⭐️ Join Our WhatsApp Channel https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A

🚀 Level up your AI & Data Science skills with HelloEncyclo — a growing all-in-one platform featuring hands-on courses in LLMs, Deep Learning, MLOps, Data Engineering, and more.
✅ 13 courses live + 40+ coming soon
🎯 One access, lifetime updates
🔑 Use code: PRESALE-BOOK-WAVE-2GFG
👉 https://helloencyclo.com/?ref=HUSSEINSHEIKHO