Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Ionchódú agus Seoladh Íomhánna i mBase64

Ceacht 5 as 12 Nuashonraithe 2 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Cén fáth Base64 a úsáid?
  2. Cathain URL a úsáid i gcomparáid le Base64
  3. Íomhá a ionchódú go Base64
  4. Formáid Data URI
  5. Sampla Iomlán
  6. Íomhánna a Ionchódú ó Fhoinsí Eile
  7. Méid a Optamú Roimh Ionchódú
  8. Teorainneacha le Bheith ar an Eolas Fúthu
  9. Príomhphointí

Cén fáth Base64 a úsáid?

Sa cheacht roimhe seo, d’fhoghlaim tú conas íomhánna a sheoladh trí URL. Mar sin féin, níl URL ag formhór na n-íomhánna a phróiseáiltear i gcomhthéacsanna gnó: sonrasc a tháinig díreach trí ríomhphost, scáileanghabháil a ghin tástáil uathoibrithe, nó grianghraf a thóg oibreoir ar líne táirgeachta. Bheadh sé absurd, agus go minic toirmiscthe, na comhaid seo a fhoilsiú ar fhreastalaí atá inrochtana ar an idirlíon díreach chun iad a anailísiú.

Anseo a thagann ionchódú Base64 isteach. Tiontaíonn sé sonraí dénártha íomhá ina shreang téacs a chuireann tú go díreach isteach in d’iarratas API, gan gá le URL seachtrach ná óstáil idirmheánach.

Cathain URL a úsáid i gcomparáid le Base64

CritéarURLBase64
Íomhánna atá óstáilte cheanaIdeálachGan ghá
Íomhánna áitiúlaNí oiriúnachIdeálach
Íomhánna a ghintear go dinimiciúilNí oiriúnachIdeálach
Moill líonraAg brath ar an bhfreastalaíGan aon mhoill (leabaithe)
Méid an iarrataisÉadromNíos troime (~33%)
Slándáil/príobháideachtURL poiblíSonraí laistigh den iarratas

Is simplí an riail: má tá an íomhá inrochtana trí URL cobhsaí, úsáid an URL. Mura bhfuil, úsáid Base64.

Íomhá a ionchódú go Base64

Níl aon spleáchais ag teastáil; soláthraíonn Python an modúl base64 ina leabharlann chaighdeánach:

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")

Níl an mód "rb" agus an comhad á oscailt roghnach: má léann tú íomhá i mód téacs, tarlóidh earráid díchódaithe. Bí ag súil le sreanga fada – méadaíonn an t-ionchódú an méid thart ar 33% i gcomparáid leis an gcomhad bunaidh, mar sin cruthaíonn íomhá 1 MB thart ar 1.33 MB téacs.

Formáid Data URI

Ní leor an tsreang amh: ní mór don API a bheith ar an eolas faoi fhormáid na híomhá. Caithfidh tú í a chur i láthair mar data URI, a chuireann réimír lena cineál MIME:

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

Freagraíonn na ceithre réimír is féidir a úsáid do na formáidí a dtacaítear leo:

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

Má fhógairt tú PNG mar image/jpeg, tarlóidh earráid próiseála; sin an fáth a bhfuil an fheidhm braite sa sampla seo a leanas.

Sampla Iomlán

Seo an slabhra iomlán, ó léamh an chomhaid áitiúil go freagra an mhúnla:

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)

An phríomhphointe: tugtar image_url ar an réimse i gcónaí, fiú nuair a bhíonn data URI ann. Ní athraíonn struchtúr na teachtaireachta faic ó Cheacht 4; níl difríocht ach san luach.

Íomhánna a Ionchódú ó Fhoinsí Eile

Níl comhad ar dhiosca ach cás amháin i measc go leor eile. Má tá d’íomhá sa chuimhne cheana féin, mar oibiacht Pillow ó ghabháil nó ó chéim próiseála, bheadh sé ina chuar gan ghá í a scríobh chuig an diosca díreach chun í a léamh ar ais láithreach bonn – oibríonn maolán cuimhne go maith:

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)

Baineann an loighic chéanna le híomhá a fhaightear trí HTTP nach dteastaíonn uait a stóráil, mar shampla toisc go dtagann sí ó nasc gearrthéarmach:

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")

Méid a Optamú Roimh Ionchódú

Meáchan 4 go 8 MB atá ag grianghraf fóin chliste inniu, rud a éiríonn beagnach 10 MB nuair a ionchódaítear é. Athróidh an API a mhéid ar aon chuma, mar a chonaic tú i gCeacht 2: bheadh tú ag íoc as an aistriú gan ghá. Mar sin, athraigh an méid i gcónaí roimh ionchódú.

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")

Ní ornáid amháin é an méid deiridh a thaispeáint: coinnigh é le linn do thástálacha, mar inseoidh sé duit láithreach an bhfuil do phíblíne ag seoladh 80 KB nó 8 MB ar gach glao.

Teorainneacha le Bheith ar an Eolas Fúthu

Tagann trí shrian le Base64. Cuireann an íomhá ionchódaithe le corp an iarratais HTTP, mar sin thar 10 MB risciú tú amanna teasa. Luchtaíonn an t-ionchódú an íomhá iomlán sa chuimhne freisin: le haghaidh próiseála baisce, déileáil le híomhánna ceann ar cheann seachas liosta de mhíle sreang ionchódaithe a thógáil. Ar deireadh, i gcodarsnacht le URLanna, athsheoltar íomhánna Base64 go hiomlán le gach iarratas – ciallaíonn anailís a dhéanamh ar an sonrasc céanna faoi dhó é a sheoladh faoi dhó.

Príomhphointí

  • Tá Base64 ideálach d’íomhánna áitiúla nó a ghintear go dinimiciúil
  • Comhcheanglaíonn formáid an data URI cineál MIME agus na sonraí: data:image/png;base64,...
  • Athraigh méid do chuid íomhánna agus comhbhrúigh iad roimh ionchódú chun moill a optamú
  • Méadaíonn Base64 an méid thart ar 33% – coinnigh do chuid íomhánna faoi 10 MB
  • Úsáid URL nuair atá an íomhá óstáilte cheana, agus Base64 i ngach cás eile