Ionchódú agus Seoladh Íomhánna i mBase64
Ar an leathanach seo
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éar | URL | Base64 |
|---|---|---|
| Íomhánna atá óstáilte cheana | Ideálach | Gan ghá |
| Íomhánna áitiúla | Ní oiriúnach | Ideálach |
| Íomhánna a ghintear go dinimiciúil | Ní oiriúnach | Ideálach |
| Moill líonra | Ag brath ar an bhfreastalaí | Gan aon mhoill (leabaithe) |
| Méid an iarratais | Éadrom | Níos troime (~33%) |
| Slándáil/príobháideacht | URL 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