Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Ikkodifika u Ibgħat Immaġini f'Base64

Lezzjoni 5 / 12 Aġġornat 2 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Għaliex Tuża Base64?
  2. Meta Tuża URL vs Base64
  3. Kif Tikkodifika Immaġini għal Base64
  4. Il-Format Data URI
  5. Eżempju Sħiħ
  6. Kif Tikkodifika Immaġini minn Sorsi Oħra
  7. Ottimizza d-Daqs Qabel ma Tikkodifika
  8. Limiti li Trid Tkun Taf
  9. Punti Ewlenin

Għaliex Tuża Base64?

Fil-lezzjoni ta’ qabel, tgħallimt kif tibgħat immaġini permezz ta’ URL. Madankollu, il-biċċa l-kbira tal-immaġini pproċessati f’kuntesti tan-negozju m’għandhomx URL: fattura li għadha kemm waslet bil-posta elettronika, screenshot iġġenerat minn test awtomatizzat, jew ritratt meħud minn operatur fuq linja tal-produzzjoni. Li tippubblika dawn il-fajls fuq server aċċessibbli mill-internet sempliċiment biex tanalizzahom ikun assurdu, u spiss projbit.

Hawnhekk tidħol il-kodifika Base64. Din tittrasforma d-dejta binarja ta’ immaġini f’string ta’ test li tinkludi direttament fit-talba tal-API tiegħek, mingħajr ma teħtieġ URL estern jew hosting intermedjarju.

Meta Tuża URL vs Base64

KriterjuURLBase64
Immaġini diġà ospitatiIdealiMhux meħtieġ
Immaġini lokaliMhux xieraqIdeali
Immaġini iġġenerati dinamikamentMhux xieraqIdeali
Latenza tan-netwerkTiddependi mis-serverL-ebda (inkorporata)
Daqs tat-talbaĦafifItqal (~33%)
Sigurtà/PrivatezzaURL pubblikuDejta fit-talba

Ir-regola hija sempliċi: jekk l-immaġini hija aċċessibbli permezz ta’ URL stabbli, uża l-URL. Inkella, uża Base64.

Kif Tikkodifika Immaġini għal Base64

M’hemmx bżonn ta’ dipendenzi; Python jipprovdi l-modulu base64 fil-librerija standard tiegħu:

import base64

def encode_image(file_path):
    """Encode an image file to a Base64 string."""
    with open(file_path, "rb") as f:
        return base64.standard_b64encode(f.read()).decode("utf-8")

# Encode a local image
image_b64 = encode_image("captures/screenshot.png")
print(f"Base64 string length: {len(image_b64)} characters")

Il-modalità "rb" meta tiftaħ il-fajl mhix għażla: li taqra immaġini f’modalità ta’ test se tqajjem żball fid-dekodifika. Stenna strings twal—il-kodifika tiżdied id-daqs b’madwar 33% meta mqabbla mal-fajl oriġinali, allura immaġini ta’ 1 MB tipproduċi madwar 1.33 MB ta’ test.

Il-Format Data URI

L-istring mhux ipproċessat mhuwiex biżżejjed: l-API trid tkun taf il-format tal-immaġini. Għalhekk, trid tippreżentaha bħala data URI, li jippreċedi d-dejta bit-tip MIME tagħha:

data:image/{format};base64,{base64_data}

L-erba’ prefissi użabbli jikkorrispondu għall-formati appoġġjati:

  • data:image/jpeg;base64,...
  • data:image/png;base64,...
  • data:image/gif;base64,...
  • data:image/webp;base64,...

Li tħabbar PNG bħala image/jpeg tikkawża żball fl-ipproċessar; għalhekk il-funzjoni ta’ detezzjoni fl-eżempju li jmiss.

Eżempju Sħiħ

Hawnhekk hija l-katina sħiħa, mill-qari tal-fajl lokali sal-risposta tal-mudell:

import base64
import os
from mistralai.client import Mistral

def encode_image(chemin):
    """Encode a local image to Base64."""
    with open(chemin, "rb") as f:
        return base64.standard_b64encode(f.read()).decode("utf-8")

# Determine MIME type
def obtenir_mime(chemin):
    """Return MIME type based on extension."""
    extensions = {
        ".jpg": "image/jpeg",
        ".jpeg": "image/jpeg",
        ".png": "image/png",
        ".gif": "image/gif",
        ".webp": "image/webp"
    }
    ext = os.path.splitext(chemin)[1].lower()
    return extensions.get(ext, "image/jpeg")

# Prepare the image
chemin_image = "documents/facture-2024.png"
image_b64 = encode_image(chemin_image)
mime_type = obtenir_mime(chemin_image)
data_uri = f"data:{mime_type};base64,{image_b64}"

# Call the API
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

response = client.chat.complete(
    model="mistral-small-latest",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Extract all information from this invoice."},
                {"type": "image_url", "image_url": data_uri}
            ]
        }
    ]
)

print(response.choices[0].message.content)

Il-punt ewlieni: il-qasam dejjem jissejjaħ image_url, anke meta fih data URI. L-istruttura tal-messaġġ ma tinbidilx affattu mil-Lezzjoni 4; biss il-valur huwa differenti.

Kif Tikkodifika Immaġini minn Sorsi Oħra

Fajl fuq id-diska huwa biss każ wieħed fost ħafna. Jekk l-immaġini tiegħek diġà teżisti fil-memorja, bħala oġġett Pillow minn pass ta’ qbid jew ipproċessar, li tiktebha fuq id-diska biss biex terġa’ taqraha immedjatament ikun devjazzjoni mhux meħtieġa—buffer tal-memorja jaħdem tajjeb:

import base64
from io import BytesIO
from PIL import Image

def pil_to_base64(pil_image):
    """Convert a Pillow image to a Base64 data URI."""
    buffer = BytesIO()
    pil_image.save(buffer, format="PNG")
    b64 = base64.standard_b64encode(buffer.getvalue()).decode("utf-8")
    return f"data:image/png;base64,{b64}"

# Example with a Pillow image
img = Image.open("capture.png")
data_uri = pil_to_base64(img)

L-istess loġika tapplika għal immaġini miksuba permezz ta’ HTTP li ma tridx taħżen, pereżempju għax tiġi minn link ta’ ħajja qasira:

import base64
import requests

def url_to_base64(url):
    """Download an image and convert it to a data URI."""
    response = requests.get(url, timeout=10)
    response.raise_for_status()
    content_type = response.headers.get("Content-Type", "image/jpeg")
    b64 = base64.standard_b64encode(response.content).decode("utf-8")
    return f"data:{content_type};base64,{b64}"

data_uri = url_to_base64("https://example.com/photo.jpg")

Ottimizza d-Daqs Qabel ma Tikkodifika

Ritratt minn smartphone illum jiżen bejn 4 u 8 MB, li jsir kważi 10 MB darba kkodifikat. L-API se tbiddel id-daqs tagħha xorta waħda, kif rajt fil-Lezzjoni 2: tkun qed tħallas għat-trasferiment għalxejn. Għalhekk, dejjem ibdel id-daqs qabel ma tikkodifika.

from PIL import Image
from io import BytesIO
import base64

def preparer_et_encoder(chemin, taille_max=1024, qualite=85):
    """Resize, compress, and encode an image."""
    img = Image.open(chemin)

    # Resize if necessary
    if max(img.size) > taille_max:
        img.thumbnail((taille_max, taille_max))

    # Convert to JPEG to reduce size
    buffer = BytesIO()
    img.convert("RGB").save(buffer, format="JPEG", quality=qualite)

    b64 = base64.standard_b64encode(buffer.getvalue()).decode("utf-8")
    taille_ko = len(buffer.getvalue()) / 1024
    print(f"Encoded image: {taille_ko:.0f} KB")

    return f"data:image/jpeg;base64,{b64}"

data_uri = preparer_et_encoder("photo_haute_resolution.png")

Li turi d-daqs finali mhix biss dekorattiva: żommha matul it-testijiet tiegħek, peress li tgħidlek immedjatament jekk il-pipeline tiegħek qed jibgħatx 80 KB jew 8 MB f’kull sejħa.

Limiti li Trid Tkun Taf

Hemm tliet restrizzjonijiet marbuta ma’ Base64. L-immaġini kkodifikata tiżdied mal-korp tat-talba HTTP, allura lil hinn minn 10 MB tirriskja timeouts. Il-kodifika wkoll tgħabbi l-immaġini sħiħa fil-memorja: għall-ipproċessar bil-biċċiet, immaniġġja l-immaġini waħda waħda minflok ma tibni lista ta’ elf string ikkodifikat. Fl-aħħar nett, kuntrarjament għall-URLs, l-immaġini Base64 jiġu ritrasmessi kompletament ma’ kull talba—li tanalizza l-istess fattura darbtejn ifisser li tibgħatha darbtejn.

Punti Ewlenin

  • Base64 huwa ideali għal immaġini lokali jew iġġenerati dinamikament
  • Il-format data URI jgħaqqad it-tip MIME u d-dejta: data:image/png;base64,...
  • Ibdel id-daqs u kkumpressja l-immaġini tiegħek qabel ma tikkodifika biex tottimizza l-latenza
  • Base64 jiżdied id-daqs b’madwar 33%—żomm l-immaġini tiegħek taħt 10 MB
  • Uża URL meta l-immaġini tkun diġà ospitata, u Base64 fil-każijiet l-oħra kollha