Image 模組

Image 模組提供一個同名的類別，用於表示 PIL 影像。此模組也提供許多工廠函式，包括從檔案載入影像和建立新影像的函式。

範例

開啟、旋轉並顯示影像 (使用預設檢視器)

以下腳本載入影像，將其旋轉 45 度，並使用外部檢視器 (在 Unix 上通常是 xv，在 Windows 上則是「小畫家」) 顯示它。

from PIL import Image
with Image.open("hopper.jpg") as im:
    im.rotate(45).show()

建立縮圖

以下腳本在目前目錄中建立所有 JPEG 影像的精美縮圖，並以 128x128 的最大解析度保留長寬比。

from PIL import Image
import glob, os

size = 128, 128

for infile in glob.glob("*.jpg"):
    file, ext = os.path.splitext(infile)
    with Image.open(infile) as im:
        im.thumbnail(size)
        im.save(file + ".thumbnail", "JPEG")

函式

PIL.Image.open(fp: StrOrBytesPath | IO[bytes], mode: Literal['r'] = 'r', formats: list[str] | tuple[str, ...] | None = None) → ImageFile.ImageFile[原始碼]

開啟並識別給定的影像檔案。

這是一個延遲操作；此函式會識別檔案，但檔案保持開啟狀態，並且直到您嘗試處理資料 (或呼叫 load() 方法) 才會從檔案讀取實際影像資料。請參閱 new()。請參閱 Pillow 中的檔案處理。

參數:

  • fp – 檔案名稱 (字串)、os.PathLike 物件或檔案物件。檔案物件必須實作 file.read、file.seek 和 file.tell 方法，並且以二進位模式開啟。檔案物件也會在讀取前搜尋至零。

  • mode – 模式。如果給定，此引數必須為 "r"。

  • formats – 嘗試載入檔案的格式清單或元組。這可以用來限制檢查的格式集。傳遞 None 以嘗試所有支援的格式。您可以執行 python3 -m PIL 或使用 PIL.features.pilinfo() 函式來列印可用的格式集。

返回:

Image 物件。

引發:

警告

為了防範潛在的阻斷服務攻擊（DOS attacks），這些攻擊可能源自「解壓縮炸彈」（也就是會解壓縮成大量資料的惡意檔案，其設計目的是透過耗盡大量記憶體來導致系統崩潰或中斷），Pillow 會在影像中的像素數量超過特定限制時發出 DecompressionBombWarning 警告，此限制值由 MAX_IMAGE_PIXELS 設定。

這個閾值可以透過設定 MAX_IMAGE_PIXELS 來變更。可以透過設定 Image.MAX_IMAGE_PIXELS = None 來停用此警告。

如果需要，可以使用 warnings.simplefilter('error', Image.DecompressionBombWarning) 將警告轉換為錯誤，或使用 warnings.simplefilter('ignore', Image.DecompressionBombWarning) 完全抑制警告。另請參閱 logging 文件，將警告輸出到記錄設施而不是 stderr。

如果像素數量大於 MAX_IMAGE_PIXELS 的兩倍，則會改為引發 DecompressionBombError 錯誤。

影像處理

PIL.Image.alpha_composite(im1: Image, im2: Image) → Image[原始碼]

將 im2 以 Alpha 混合方式疊加在 im1 上。

參數:

  • im1 – 第一個影像。必須為 RGBA 模式。

  • im2 – 第二個影像。必須為 RGBA 模式，並且大小必須與第一個影像相同。

返回:

Image 物件。

PIL.Image.blend(im1: Image, im2: Image, alpha: float) → Image[原始碼]

透過在兩個輸入影像之間插值，並使用一個常數 alpha 值來建立新的影像。

out = image1 * (1.0 - alpha) + image2 * alpha
參數:

  • im1 – 第一個影像。

  • im2 – 第二個影像。必須與第一個影像具有相同的模式和大小。

  • alpha – 插值 alpha 因子。如果 alpha 為 0.0，則會回傳第一個影像的副本。如果 alpha 為 1.0，則會回傳第二個影像的副本。對 alpha 值沒有任何限制。如有必要，結果將被裁剪以符合允許的輸出範圍。

返回:

Image 物件。

PIL.Image.composite(image1: Image, image2: Image, mask: Image) → Image[原始碼]

使用透明遮罩混合影像來建立合成影像。

參數:

  • image1 – 第一個影像。

  • image2 – 第二個影像。必須與第一個影像具有相同的模式和大小。

  • mask – 遮罩影像。此影像可以具有 “1”、”L” 或 “RGBA” 模式，並且必須與其他兩個影像具有相同的大小。

PIL.Image.eval(image: Image, *args: Callable[[int], float]) → Image[原始碼]

將函數（應接受一個引數）套用至給定影像中的每個像素。如果影像有多個波段，則會將相同的函數套用至每個波段。請注意，該函數會針對每個可能的像素值評估一次，因此您不能使用隨機元件或其他產生器。

參數:

  • image – 輸入影像。

  • function – 函數物件，接受一個整數引數。

返回:

Image 物件。

PIL.Image.merge(mode: str, bands: Sequence[Image]) → Image[原始碼]

將一組單波段影像合併成新的多波段影像。

參數:

  • mode – 要用於輸出影像的模式。請參閱：模式。

  • bands – 一個序列，其中包含輸出影像中每個波段的一個單波段影像。所有波段的大小必須相同。

返回:

Image 物件。

建構影像

PIL.Image.new(mode: str, size: tuple[int, int] | list[int], color: float | tuple[float, ...] | str | None = 0) → Image[原始碼]

建立具有指定模式和大小的新影像。

參數:

  • mode – 新影像要使用的模式。請參閱：模式。

  • size – 一個包含 (寬度, 高度) 像素的 2 元組。

  • color – 影像要使用的顏色。預設為黑色。如果指定此值，則單波段模式應為單一整數或浮點數值，而多波段模式應為元組（每個波段一個值）。建立 RGB 或 HSV 影像時，您也可以使用 ImageColor 模組支援的顏色字串。如果顏色為 None，則不會初始化影像。

返回:

Image 物件。

PIL.Image.fromarray(obj: SupportsArrayInterface, mode: str | None = None) → Image[原始碼]

從匯出陣列介面（使用緩衝區協定）的物件建立影像記憶體。

from PIL import Image
import numpy as np
a = np.zeros((5, 5))
im = Image.fromarray(a)

如果 obj 不是連續的，則會呼叫 tobytes 方法，並使用 frombuffer()。

就 NumPy 而言，請注意 Pillow 模式並不總是與 NumPy dtypes 對應。Pillow 模式僅提供 1 位元像素、8 位元像素、32 位元帶符號整數像素和 32 位元浮點數像素。

Pillow 影像也可以轉換為陣列。

from PIL import Image
import numpy as np
im = Image.open("hopper.jpg")
a = np.asarray(im)

但是，當將 Pillow 影像轉換為陣列時，只會傳輸像素值。這表示 P 和 PA 模式影像會遺失其調色盤。

參數:

  • obj – 具有陣列介面的物件

  • mode –

    讀取 obj 時要使用的可選模式。如果 None，將從類型確定。

    這不會用於讀取後轉換資料，但會用於變更讀取資料的方式。

    from PIL import Image
import numpy as np
a = np.full((1, 1), 300)
im = Image.fromarray(a, mode="L")
im.getpixel((0, 0))  # 44
im = Image.fromarray(a, mode="RGB")
im.getpixel((0, 0))  # (44, 1, 0)

    有關模式的一般資訊，請參閱：模式。

返回:

一個影像物件。

在 1.1.6 版中新增。

PIL.Image.frombytes(mode: str, size: tuple[int, int], data: bytes | bytearray | SupportsArrayInterface, decoder_name: str = 'raw', *args: Any) → Image[原始碼]

從緩衝區中的像素資料建立影像記憶體的複本。

在最簡單的形式中，此函數接受三個引數（模式、大小和未壓縮的像素資料）。

您也可以使用 PIL 支援的任何像素解碼器。有關可用解碼器的更多資訊，請參閱 撰寫您自己的檔案編碼器 一節。

請注意，此函數僅解碼像素資料，而不是整個影像。如果您的字串中有整個影像，請將它包裝在 BytesIO 物件中，並使用 open() 載入它。

參數:

  • mode – 影像模式。請參閱：模式。

  • size – 影像大小。

  • data – 包含指定模式原始資料的位元組緩衝區。

  • decoder_name – 要使用的解碼器。

  • args – 給定解碼器的其他參數。

返回:

Image 物件。

PIL.Image.frombuffer(mode: str, size: tuple[int, int], data: bytes | SupportsArrayInterface, decoder_name: str = 'raw', *args: Any) → Image[原始碼]

建立一個影像，其記憶體參考於位元組緩衝區中的像素資料。

此函式類似於 frombytes()，但盡可能使用位元組緩衝區中的資料。這表示對原始緩衝區物件的變更會反映在此影像中。並非所有模式都可以共享記憶體；支援的模式包括「L」、「RGBX」、「RGBA」和「CMYK」。

請注意，此函式僅解碼像素資料，而非整個影像。如果您在字串中包含整個影像檔案，請將其包裝在 BytesIO 物件中，並使用 open() 載入它。

「raw」解碼器使用的預設參數與 frombytes() 使用的參數不同。這是一個錯誤，並且可能會在未來的版本中修復。目前版本會在您執行此操作時發出警告；若要停用警告，您應提供完整的參數集。請參閱下文以了解詳細資訊。

參數:

  • mode – 影像模式。請參閱：模式。

  • size – 影像大小。

  • data – 包含指定模式的原始資料的位元組或其他緩衝區物件。

  • decoder_name – 要使用的解碼器。

  • args –

    指定解碼器的其他參數。對於預設編碼器（「raw」），建議您提供完整的參數集

    frombuffer(mode, size, data, "raw", mode, 0, 1)

返回:

Image 物件。

在 1.1.4 版本中新增。

產生影像

PIL.Image.effect_mandelbrot(size: tuple[int, int], extent: tuple[float, float, float, float], quality: int) → Image[原始碼]

產生覆蓋指定範圍的曼德布羅集。

參數:

  • size – 要求的像素大小，以 2 元組表示：(寬度, 高度)。

  • extent – 要覆蓋的範圍，以 4 元組表示：(x0, y0, x1, y1)。

  • quality – 品質。

PIL.Image.effect_noise(size: tuple[int, int], sigma: float) → Image[原始碼]

產生以 128 為中心的 Gaussian 雜訊。

參數:

  • size – 要求的像素大小，以 2 元組表示：(寬度, 高度)。

  • sigma – 雜訊的標準差。

PIL.Image.linear_gradient(mode: str) → Image[原始碼]

產生從黑色到白色、從上到下的 256x256 線性漸層。

參數:

mode – 輸入模式。

PIL.Image.radial_gradient(mode: str) → Image[原始碼]

產生從黑色到白色、從中心到邊緣的 256x256 放射狀漸層。

參數:

mode – 輸入模式。

註冊外掛程式

PIL.Image.preinit() → None[原始碼]

明確載入 BMP、GIF、JPEG、PPM 和 PPM 檔案格式驅動程式。

它會在開啟或儲存影像時呼叫。

PIL.Image.init() → bool[原始碼]

明確初始化 Python Imaging Library。此函式載入所有可用的檔案格式驅動程式。

如果 preinit() 不足，並且由 pilinfo() 呼叫，則會在開啟或儲存影像時呼叫。

注意

這些函式供外掛程式作者使用。當外掛程式作為 preinit() 或 init() 的一部分載入時，會呼叫它們。應用程式作者可以忽略它們。

PIL.Image.register_open(id: str, factory: Callable[[IO[bytes], str | bytes], ImageFile.ImageFile] | type[ImageFile.ImageFile], accept: Callable[[bytes], bool | str] | None = None) → None[原始碼]

註冊一個影像檔案外掛程式。此函式不應在應用程式碼中使用。

參數:

  • id – 影像格式識別碼。

  • factory – 影像檔案工廠方法。

  • accept – 一個可選的函式，可用於快速拒絕具有其他格式的影像。

PIL.Image.register_mime(id: str, mimetype: str) → None[原始碼]

透過填入 Image.MIME 來註冊影像 MIME 類型。此函式不應在應用程式碼中使用。

Image.MIME 提供從影像格式識別碼到 mime 格式的對應，但 get_format_mimetype() 可以針對特定影像提供不同的結果。

參數:

  • id – 影像格式識別碼。

  • mimetype – 此格式的影像 MIME 類型。

PIL.Image.register_save(id: str, driver: Callable[[Image, IO[bytes], str | bytes], None]) → None[原始碼]

註冊一個影像儲存函式。此函式不應在應用程式碼中使用。

參數:

  • id – 影像格式識別碼。

  • driver – 以此格式儲存影像的函式。

PIL.Image.register_save_all(id: str, driver: Callable[[Image, IO[bytes], str | bytes], None]) → None[原始碼]

註冊一個影像函式，以儲存多幀格式的所有幀。此函式不應在應用程式碼中使用。

參數:

  • id – 影像格式識別碼。

  • driver – 以此格式儲存影像的函式。

PIL.Image.register_extension(id: str, extension: str) → None[原始碼]

註冊一個影像副檔名。此函式不應在應用程式碼中使用。

參數:

  • id – 影像格式識別碼。

  • extension – 用於此格式的副檔名。

PIL.Image.register_extensions(id: str, extensions: list[str]) → None[原始碼]

註冊影像副檔名。此函式不應在應用程式碼中使用。

參數:

  • id – 影像格式識別碼。

  • extensions – 用於此格式的副檔名清單。

PIL.Image.registered_extensions() → dict[str, str][原始碼]

返回包含屬於已註冊外掛程式的所有檔案副檔名的字典

PIL.Image.register_decoder(name: str, decoder: type[ImageFile.PyDecoder]) → None[原始碼]

註冊一個影像解碼器。此函式不應在應用程式碼中使用。

參數:

  • name – 解碼器的名稱

  • decoder – 一個 ImageFile.PyDecoder 物件

在 4.1.0 版本中新增。

PIL.Image.register_encoder(name: str, encoder: type[ImageFile.PyEncoder]) → None[原始碼]

註冊一個影像編碼器。此函式不應在應用程式碼中使用。

參數:

  • name – 編碼器的名稱

  • encoder – 一個 ImageFile.PyEncoder 物件

在 4.1.0 版本中新增。

影像類別

class PIL.Image.Image[原始碼]

此類別代表一個影像物件。若要建立 Image 物件，請使用適當的工廠函式。幾乎沒有理由直接呼叫 Image 建構子。

Image 類別的實例具有下列方法。除非另有說明，所有方法都會傳回 Image 類別的新實例，其中包含產生的影像。

Image.alpha_composite(im: Image, dest: Sequence[int] = (0, 0), source: Sequence[int] = (0, 0)) → None[原始碼]

與 Image.alpha_composite 相同的「原地」操作。將影像合成到此影像上。

參數:

  • im – 要合成到此影像上的影像

  • dest – 可選的 2 元組 (左, 上)，指定此 (目標) 影像中的左上角。

  • source – 可選的 2 元組 (左, 上)，指定覆蓋來源影像中的左上角，或是 4 元組 (左, 上, 右, 下)，指定來源矩形的邊界

效能注意事項：目前在核心層中並未實作原地操作。

Image.apply_transparency() → None[原始碼]

如果 P 模式影像在 info 字典中有「transparency」鍵，則移除該鍵，並改為將透明度套用到調色盤。否則，影像不會變更。

Image.convert(mode: str | None = None, matrix: tuple[float, ...] | None = None, dither: Dither | None = None, palette: Palette = Palette.WEB, colors: int = 256) → Image[原始碼]

傳回此影像的轉換副本。對於「P」模式，此方法會透過調色盤轉換像素。如果省略 mode，則會選擇一個模式，以便在不使用調色盤的情況下表示影像和調色盤中的所有資訊。

這支援「L」、「RGB」和「CMYK」之間的所有可能轉換。matrix 引數僅支援「L」和「RGB」。

將彩色影像轉換為灰階 (模式「L」) 時，程式庫會使用 ITU-R 601-2 亮度轉換

L = R * 299/1000 + G * 587/1000 + B * 114/1000

將灰階 (「L」) 或「RGB」影像轉換為雙層 (模式「1」) 影像的預設方法會使用 Floyd-Steinberg 抖動來近似原始影像的亮度層級。如果 dither 為 None，則大於 127 的所有值都會設定為 255 (白色)，所有其他值設定為 0 (黑色)。若要使用其他臨界值，請使用 point() 方法。

當從「RGBA」轉換為「P」且沒有 matrix 引數時，這會將操作傳遞至 quantize()，並忽略 dither 和 palette。

當從「PA」轉換時，如果存在「RGBA」調色盤，則會使用影像中的 alpha 色版，而不是調色盤中的值。

參數:

  • mode – 請求的模式。請參閱：模式。

  • matrix – 可選的轉換矩陣。如果提供此矩陣，則應為包含浮點數值的 4 元組或 12 元組。

  • dither (抖色) – 抖色方法，用於將模式從「RGB」轉換為「P」，或從「RGB」或「L」轉換為「1」時。 可用的方法有 Dither.NONE 或 Dither.FLOYDSTEINBERG (預設)。 請注意，當提供 matrix 時，不會使用此參數。

  • palette (調色盤) – 將模式從「RGB」轉換為「P」時使用的調色盤。 可用的調色盤有 Palette.WEB 或 Palette.ADAPTIVE。

  • colors (顏色數) – 用於 Palette.ADAPTIVE 調色盤的顏色數量。預設為 256。

回傳類型:

Image (影像)

返回:

Image 物件。

以下範例將 RGB 影像（根據 ITU-R 709 線性校準，使用 D65 光源）轉換為 CIE XYZ 色彩空間

rgb2xyz = (
    0.412453, 0.357580, 0.180423, 0,
    0.212671, 0.715160, 0.072169, 0,
    0.019334, 0.119193, 0.950227, 0)
out = im.convert("RGB", rgb2xyz)
Image.copy() → Image[原始碼]

複製此影像。如果您希望將內容貼到影像中，但仍保留原始影像，請使用此方法。

回傳類型:

Image (影像)

返回:

Image 物件。

Image.crop(box: tuple[float, float, float, float] | None = None) → Image[原始碼]

從此影像返回一個矩形區域。該 box (方框) 是一個 4 元組，定義左、上、右和下像素座標。請參閱 座標系統。

注意：在 Pillow 3.4.0 之前，這是一個惰性操作。

參數:

box (方框) – 裁剪矩形，作為一個 (左, 上, 右, 下) 元組。

回傳類型:

Image (影像)

返回:

Image 物件。

這會使用提供的座標裁剪輸入影像

from PIL import Image

with Image.open("hopper.jpg") as im:

    # The crop method from the Image module takes four coordinates as input.
    # The right can also be represented as (left+width)
    # and lower can be represented as (upper+height).
    (left, upper, right, lower) = (20, 20, 100, 100)

    # Here the image "im" is cropped and assigned to new variable im_crop
    im_crop = im.crop((left, upper, right, lower))
Image.draft(mode: str | None, size: tuple[int, int] | None) → tuple[str, tuple[int, int, float, float]] | None[原始碼]

配置影像檔案載入器，使其返回與給定模式和大小盡可能匹配的影像版本。 例如，您可以使用此方法在載入時將彩色 JPEG 轉換為灰階。

如果進行任何變更，則返回一個元組，其中包含選擇的 mode (模式) 和 box (方框)，其中包含原始影像在已變更影像中的座標。

請注意，此方法會就地修改 Image 物件。 如果影像已經載入，則此方法無效。

注意：此方法未針對大多數影像實作。 目前僅針對 JPEG 和 MPO 影像實作。

參數:

  • mode (模式) – 請求的模式。

  • size – 要求的像素大小，以 2 元組表示：(寬度, 高度)。

Image.effect_spread(distance: int) → Image[原始碼]

隨機散佈影像中的像素。

參數:

distance (距離) – 散佈像素的距離。

Image.entropy(mask: Image | None = None, extrema: tuple[float, float] | None = None) → float[原始碼]

計算並返回影像的熵值。

雙位元影像（模式「1」）會被此方法視為灰階（「L」）影像。

如果提供遮罩，則該方法會使用影像中遮罩影像非零部分的直方圖。 遮罩影像的大小必須與影像相同，並且必須是雙位元影像（模式「1」）或灰階影像（「L」）。

參數:

  • mask (遮罩) – 可選的遮罩。

  • extrema (極值) – 可選的手動指定極值元組。

返回:

表示影像熵值的浮點數值

Image.filter(filter: ImageFilter.Filter | type[ImageFilter.Filter]) → Image[原始碼]

使用指定的濾鏡來過濾此影像。如需可用的濾鏡列表，請參閱 ImageFilter 模組。

參數:

filter – 濾鏡核心。

返回:

Image 物件。

此操作會使用 ImageFilter 模組中的濾鏡來模糊輸入影像

from PIL import Image, ImageFilter

with Image.open("hopper.jpg") as im:

    # Blur the input image using the filter ImageFilter.BLUR
    im_blurred = im.filter(filter=ImageFilter.BLUR)
Image.frombytes(data: bytes | bytearray | SupportsArrayInterface, decoder_name: str = 'raw', *args: Any) → None[原始碼]

從位元組物件載入此影像的像素資料。

此方法類似於 frombytes() 函式，但會將資料載入此影像中，而不是建立新的影像物件。

Image.getbands() → tuple[str, ...][原始碼]

傳回一個元組，其中包含此影像中每個色帶的名稱。例如，RGB 影像上的 getbands 會傳回 ("R", "G", "B")。

返回:

包含色帶名稱的元組。

回傳類型:

元組

這有助於取得輸入影像的色帶

from PIL import Image

with Image.open("hopper.jpg") as im:
    print(im.getbands())  # Returns ('R', 'G', 'B')
Image.getbbox(*, alpha_only: bool = True) → tuple[int, int, int, int] | None[原始碼]

計算影像中非零區域的邊界框。

參數:

alpha_only – 選用旗標，預設為 True。如果為 True 且影像具有 alpha 通道，則會修剪透明像素。否則，當所有通道皆為零時，會修剪像素。僅限關鍵字引數。

返回:

邊界框會以 4 元組形式傳回，定義左、上、右和下像素座標。請參閱 座標系統。如果影像完全空白，此方法會傳回 None。

這有助於取得輸入影像的邊界框座標

from PIL import Image

with Image.open("hopper.jpg") as im:
    print(im.getbbox())
    # Returns four coordinates in the format (left, upper, right, lower)
Image.getchannel(channel: int | str) → Image[原始碼]

傳回包含來源影像單一通道的影像。

參數:

channel – 要傳回的通道。可以是索引（對於「RGB」的「R」通道為 0），或通道名稱（對於「RGBA」的 alpha 通道為「A」）。

返回:

「L」模式的影像。

於版本 4.3.0 中新增。

Image.getcolors(maxcolors: int = 256) → list[tuple[int, tuple[int, ...]]] | list[tuple[int, float]] | None[原始碼]

傳回此影像中使用的色彩清單。

色彩將會以影像的模式呈現。例如，RGB 影像會傳回 (紅色、綠色、藍色) 色彩值的元組，而 P 影像則會傳回調色盤中色彩的索引。

參數:

maxcolors – 最大色彩數。如果超過此數字，此方法會傳回 None。預設限制為 256 種色彩。

返回:

未排序的 (計數、像素) 值清單。

Image.getdata(band: int | None = None) → core.ImagingCore[原始碼]

將此影像的內容傳回為包含像素值的序列物件。序列物件是扁平化的，因此第一行的值會直接接在第零行的值之後，依此類推。

請注意，此方法傳回的序列物件是內部 PIL 資料類型，僅支援某些序列操作。若要將其轉換為一般序列（例如用於列印），請使用 list(im.getdata())。

參數:

band – 要傳回的色帶。預設值為傳回所有色帶。若要傳回單一色帶，請傳入索引值（例如，傳入 0 以從「RGB」影像取得「R」色帶）。

返回:

類似序列的物件。

Image.getexif() → Exif[原始碼]

從影像取得 EXIF 資料。

返回:

一個 Exif 物件。

Image.getextrema() → tuple[float, float] | tuple[tuple[int, int], ...][原始碼]

取得影像中每個色帶的最小和最大像素值。

返回:

對於單色帶影像，會回傳一個包含最小和最大像素值的 2 元組。對於多色帶影像，會回傳一個包含每個色帶的 2 元組的元組。

Image.getpalette(rawmode: str | None = 'RGB') → list[int] | None[原始碼]

以列表形式回傳影像的調色盤。

參數:

rawmode –

回傳調色盤時使用的模式。 None 會以目前的模式回傳調色盤。

於 9.1.0 版本新增。

返回:

顏色值的列表 [r, g, b, …]，如果影像沒有調色盤，則回傳 None。

Image.getpixel(xy: tuple[int, int] | list[int]) → float | tuple[int, ...] | None[原始碼]

回傳指定位置的像素值。

參數:

xy – 以 (x, y) 形式提供的座標。 請參閱座標系統。

返回:

像素值。如果影像為多圖層影像，則此方法會回傳一個元組。

Image.getprojection() → tuple[list[int], list[int]][原始碼]

取得 X 軸和 Y 軸的投影

返回:

兩個序列，分別表示沿著 X 軸和 Y 軸有哪些非零像素。

Image.getxmp() → dict[str, Any][原始碼]

回傳包含 XMP 標籤的字典。需要安裝 defusedxml。

返回:

以字典形式呈現的 XMP 標籤。

Image.histogram(mask: Image | None = None, extrema: tuple[float, float] | None = None) → list[int][原始碼]

回傳影像的直方圖。直方圖會以像素計數列表的形式回傳，來源影像中的每個像素值都有一個計數。即使影像每個色帶超過 8 位元，計數也會分組到每個色帶的 256 個 bin 中。如果影像有多個色帶，則會串連所有色帶的直方圖（例如，「RGB」影像的直方圖包含 768 個值）。

雙位元影像（模式「1」）會被此方法視為灰階（「L」）影像。

如果提供遮罩，則此方法會回傳影像中遮罩影像非零部分的直方圖。遮罩影像的大小必須與影像相同，而且必須是雙色調影像（模式「1」）或灰階影像（「L」）。

參數:

  • mask (遮罩) – 可選的遮罩。

  • extrema (極值) – 可選的手動指定極值元組。

返回:

包含像素計數的列表。

Image.paste(im: Image | str | float | tuple[float, ...], box: Image | tuple[int, int, int, int] | tuple[int, int] | None = None, mask: Image | None = None) → None[原始碼]

將另一個影像貼到此影像上。box 引數可以是 2 個元素的元組（表示左上角座標）、4 個元素的元組（定義左、上、右和下像素座標），或 None（與 (0, 0) 相同）。請參閱座標系統。如果給定 4 個元素的元組，則貼上的影像大小必須與區域大小相符。

如果模式不符，則貼上的影像會轉換為此影像的模式（詳細資訊請參閱convert()方法）。

來源可以是整數或包含像素值的元組，而不是影像。然後，此方法會使用指定的顏色填滿該區域。建立 RGB 影像時，您也可以使用 ImageColor 模組支援的顏色字串。

如果給定遮罩，此方法只會更新遮罩指示的區域。您可以使用「1」、「L」、「LA」、「RGBA」或「RGBa」影像（如果存在，alpha 帶會用作遮罩）。遮罩為 255 的地方，會直接複製指定的影像。遮罩為 0 的地方，會保留目前的值。介於兩者之間的值會將兩個影像混合在一起，包括它們的 alpha 通道（如果有的話）。

如果您想要根據影像的 alpha 通道組合影像，請參閱alpha_composite()。

參數:

  • im – 來源影像或像素值（整數、浮點數或元組）。

  • box –

    一個可選的 4 個元素元組，用於指定要貼入的區域。如果改用 2 個元素的元組，則會將其視為左上角。如果省略或為 None，則會將來源貼到左上角。

    如果將影像作為第二個引數提供，且沒有第三個引數，則 box 會預設為 (0, 0)，並且第二個引數會被解釋為遮罩影像。

  • mask – 一個可選的遮罩影像。

Image.point(lut: Sequence[float] | NumpyArray | Callable[[int], float] | Callable[[ImagePointTransform], ImagePointTransform | float] | ImagePointHandler, mode: str | None = None) → Image[原始碼]

透過查閱表或函式對此影像進行映射。

參數:

  • lut –

    查閱表，其中包含影像中每個頻段 256 個值（如果 self.mode==”I” 且 mode == “L”，則為 65536 個）。也可以使用函式，它應接受單一引數。針對每個可能的像素值會呼叫此函式一次，且產生的表格會套用至影像的所有頻段。

    它也可以是 ImagePointHandler 物件。

    class Example(Image.ImagePointHandler):
  def point(self, im: Image) -> Image:
    # Return result

  • mode – 輸出模式（預設值與輸入相同）。只有在來源影像的模式為「L」或「P」，且輸出模式為「1」時，或是來源影像模式為「I」且輸出模式為「L」時，才能使用此模式。

返回:

Image 物件。

Image.putalpha(alpha: Image | int) → None[原始碼]

在此影像中新增或取代 alpha 圖層。如果影像沒有 alpha 圖層，則會將其轉換為「LA」或「RGBA」。新的圖層必須是「L」或「1」。

參數:

alpha – 新的 alpha 圖層。可以是與此影像大小相同的「L」或「1」影像，也可以是整數。

Image.putdata(data: Sequence[float] | Sequence[Sequence[int]] | core.ImagingCore | NumpyArray, scale: float = 1.0, offset: float = 0.0) → None[原始碼]

將扁平化的序列物件中的像素資料複製到影像中。這些值應從左上角 (0, 0) 開始，持續到該行的結尾，然後直接接續第二行的第一個值，依此類推。資料將會讀取直到影像或序列結束。縮放和偏移值用於調整序列值：像素 = 值 * 縮放 + 偏移。

參數:

  • data – 一個扁平化的序列物件。

  • scale – 一個可選的縮放值。預設值為 1.0。

  • offset – 一個可選的偏移值。預設值為 0.0。

Image.putpalette(data: ImagePalette.ImagePalette | bytes | Sequence[int], rawmode: str = 'RGB') → None[原始碼]

將調色盤附加到此影像。影像必須是 “P”、“PA”、“L” 或 “LA” 影像。

調色盤序列最多必須包含 256 種顏色，由原始模式中每個通道的一個整數值組成。例如，如果原始模式是 “RGB”，則它最多可以包含 768 個值，由 256 種顏色中對應像素索引的紅色、綠色和藍色值組成。如果原始模式是 “RGBA”，則它最多可以包含 1024 個值，包含紅色、綠色、藍色和 Alpha 值。

或者，可以使用 8 位元字串來代替整數序列。

參數:

  • data – 調色盤序列（可以是列表或字串）。

  • rawmode – 調色盤的原始模式。可以是 “RGB”、“RGBA”，或可以轉換為 “RGB” 或 “RGBA” 的模式（例如 “R”、“BGR;15”、“RGBA;L”）。

Image.putpixel(xy: tuple[int, int], value: float | tuple[int, ...] | list[int]) → None[原始碼]

修改指定位置的像素。對於單頻帶影像，顏色以單個數值表示；對於多頻帶影像，顏色以元組表示。此外，P 和 PA 影像也接受 RGB 和 RGBA 元組。

請注意，此方法相對較慢。對於更廣泛的更改，請改用 paste() 或 ImageDraw 模組。

請參閱

參數:

  • xy – 像素坐標，以 (x, y) 的形式給定。請參閱 座標系統。

  • value – 像素值。

Image.quantize(colors: int = 256, method: int | None = None, kmeans: int = 0, palette: Image | None = None, dither: Dither = Dither.FLOYDSTEINBERG) → Image[原始碼]

將影像轉換為具有指定顏色數量的 ‘P’ 模式。

參數:
返回:

新的影像

Image.reduce(factor: int | tuple[int, int], box: tuple[int, int, int, int] | None = None) → Image[原始碼]

傳回影像縮小 factor 倍的副本。如果影像大小無法被 factor 整除，則產生的尺寸將會向上捨入。

參數:

  • factor – 大於 0 的整數，或兩個整數的元組，分別代表寬度和高度。

  • box – 一個可選的 4 個整數的元組，提供要縮小的來源影像區域。這些值必須在 (0, 0, width, height) 矩形內。如果省略或為 None，則會使用整個來源。

Image.remap_palette(dest_map: list[int], source_palette: bytes | bytearray | None = None) → Image[原始碼]

重寫影像以重新排序調色盤。

參數:

  • dest_map – 原始調色盤索引的列表。例如，[1,0] 會交換兩個項目的調色盤，而 list(range(256)) 則是恆等轉換。

  • source_palette – 位元組或 None。

返回:

Image 物件。

Image.resize(size: tuple[int, int] | list[int] | NumpyArray, resample: int | None = None, box: tuple[float, float, float, float] | None = None, reducing_gap: float | None = None) → Image[原始碼]

傳回此影像的調整大小副本。

參數:

  • size – 以像素為單位請求的大小，以元組或陣列表示：(寬度, 高度)。

  • resample – 一個可選的重新取樣濾波器。這可以是 Resampling.NEAREST、Resampling.BOX、Resampling.BILINEAR、Resampling.HAMMING、Resampling.BICUBIC 或 Resampling.LANCZOS 其中之一。如果影像的模式為 “1” 或 “P”，則它始終設定為 Resampling.NEAREST。如果影像模式為 “BGR;15”、“BGR;16” 或 “BGR;24”，則預設濾波器為 Resampling.NEAREST。否則，預設濾波器為 Resampling.BICUBIC。請參閱：濾波器。

  • box – 一個可選的 4 個浮點數的元組，提供要縮放的來源影像區域。這些值必須在 (0, 0, width, height) 矩形內。如果省略或為 None，則會使用整個來源。

  • reducing_gap – 透過兩個步驟來調整影像大小，以進行最佳化處理。首先，使用 reduce() 將影像縮小整數倍。接著，使用常規的重新取樣調整大小。最後一步調整的大小至少會變動 reducing_gap 倍。reducing_gap 可以是 None (不執行第一步驟) 或應該大於 1.0。 reducing_gap 越大，結果越接近公平取樣。 reducing_gap 越小，調整大小的速度越快。當 reducing_gap 大於或等於 3.0 時，在大多數情況下，結果與公平取樣難以區分。預設值為 None (不進行最佳化)。

返回:

Image 物件。

這會將給定的影像從 (width, height) 調整大小為 (width/2, height/2)

from PIL import Image

with Image.open("hopper.jpg") as im:

    # Provide the target width and height of the image
    (width, height) = (im.width // 2, im.height // 2)
    im_resized = im.resize((width, height))
Image.rotate(angle: float, resample: Resampling = Resampling.NEAREST, expand: int | bool = False, center: tuple[float, float] | None = None, translate: tuple[int, int] | None = None, fillcolor: float | tuple[float, ...] | str | None = None) → Image[原始碼]

傳回此影像的旋轉副本。此方法會傳回此影像的副本，並依給定的度數繞其中心逆時針旋轉。

參數:

  • angle – 以逆時針方向計算的角度（以度為單位）。

  • resample – 可選的重新取樣濾鏡。可以是 Resampling.NEAREST (使用最近鄰)，Resampling.BILINEAR (在 2x2 環境中使用線性插值)，或 Resampling.BICUBIC (在 4x4 環境中使用三次樣條插值)。如果省略，或影像的模式為「1」或「P」，則會設定為 Resampling.NEAREST。請參閱 濾鏡。

  • expand – 可選的擴展旗標。如果為 true，則擴展輸出影像，使其足夠大以容納整個旋轉影像。如果為 false 或省略，則使輸出影像與輸入影像的大小相同。請注意，expand 旗標假設繞中心旋轉且沒有平移。

  • center – 可選的旋轉中心（2 個元素的 tuple）。原點是左上角。預設值是影像的中心。

  • translate – 可選的旋轉後平移（2 個元素的 tuple）。

  • fillcolor – 旋轉影像外部區域的可選顏色。

返回:

Image 物件。

這會將輸入影像逆時針旋轉 theta 度

from PIL import Image

with Image.open("hopper.jpg") as im:

    # Rotate the image by 60 degrees counter clockwise
    theta = 60
    # Angle is in degrees counter clockwise
    im_rotated = im.rotate(angle=theta)
Image.save(fp: StrOrBytesPath | IO[bytes], format: str | None = None, **params: Any) → None[原始碼]

將此影像儲存到指定的檔案名稱下。如果沒有指定格式，則會盡可能從檔案名稱副檔名判斷要使用的格式。

可以使用關鍵字選項為寫入器提供額外的指示。如果寫入器無法識別某個選項，則會直接忽略。每個寫入器的可用選項都記錄在影像格式說明文件中。

您可以使用檔案物件而不是檔案名稱。在這種情況下，您必須始終指定格式。檔案物件必須實作 seek、 tell 和 write 方法，並以二進位模式開啟。

參數:

  • fp – 檔案名稱（字串）、os.PathLike 物件或檔案物件。

  • format – 可選的格式覆寫。如果省略，則會從檔案名稱副檔名判斷要使用的格式。如果使用檔案物件而不是檔案名稱，則應始終使用此參數。

  • params – 影像寫入器的額外參數。

返回:

None

引發:

  • ValueError – 如果無法從檔案名稱判斷輸出格式。使用 format 選項來解決此問題。

  • OSError – 如果無法寫入檔案。檔案可能已建立，並且可能包含部分資料。

Image.seek(frame: int) → None[原始碼]

在此序列檔案中搜尋給定的影格。如果搜尋超出序列結尾，該方法會引發 EOFError 例外。當開啟序列檔案時，程式庫會自動搜尋到影格 0。

請參閱 tell()。

如果已定義，n_frames 指的是可用影格的數量。

參數:

frame – 影格編號，從 0 開始。

引發:

EOFError – 如果呼叫嘗試搜尋超出序列結尾。

Image.show(title: str | None = None) → None[原始碼]

顯示此影像。此方法主要用於除錯目的。

此方法在內部呼叫 PIL.ImageShow.show()。您可以使用 PIL.ImageShow.register() 來覆寫其預設行為。

影像會先儲存到一個暫存檔案。預設情況下，它會是 PNG 格式。

在 Unix 系統上，影像會使用 xdg-open、display、gm、eog 或 xv 工具開啟，具體取決於哪個工具可以找到。

在 macOS 系統上，影像會使用原生的「預覽」應用程式開啟。

在 Windows 系統上，影像會使用標準的 PNG 顯示工具開啟。

參數:

title – 可選的標題，用於影像視窗，如果可以的話。

Image.split() → tuple[Image, ...][原始碼]

將此影像分割成個別的色帶。此方法會從影像傳回個別影像色帶的元組。例如，分割 “RGB” 影像會建立三個新的影像，每個影像都包含原始色帶 (紅色、綠色、藍色) 的一個副本。

如果您只需要一個色帶，則 getchannel() 方法可能更方便且更快。

返回:

一個包含色帶的元組。

Image.tell() → int[原始碼]

傳回目前的影格編號。請參閱 seek()。

如果已定義，n_frames 指的是可用影格的數量。

返回:

影格編號，從 0 開始。

Image.thumbnail(size: tuple[float, float], resample: Resampling = Resampling.BICUBIC, reducing_gap: float | None = 2.0) → None[原始碼]

將此影像製作成縮圖。此方法會修改影像，使其包含本身的縮圖版本，大小不大於給定的大小。此方法會計算適當的縮圖大小以保留影像的長寬比，呼叫 draft() 方法來設定檔案讀取器 (如果適用)，最後調整影像大小。

請注意，此函式會就地修改 Image 物件。如果您也需要使用完整解析度的影像，請將此方法應用於原始影像的 copy()。

參數:

  • size – 要求的像素大小，以 2 元組表示：(寬度, 高度)。

  • resample – 可選的重新取樣濾鏡。它可以是 Resampling.NEAREST、Resampling.BOX、Resampling.BILINEAR、Resampling.HAMMING、Resampling.BICUBIC 或 Resampling.LANCZOS 之一。如果省略，則預設為 Resampling.BICUBIC。(在 2.5.0 版本之前為 Resampling.NEAREST)。請參閱：濾鏡。

  • reducing_gap – 透過兩個步驟調整影像大小來應用最佳化。首先，使用 reduce() 或 draft() 來縮小影像的整數倍數 (適用於 JPEG 影像)。其次，使用規則的重新取樣調整大小。最後一步變更的大小不小於 reducing_gap 倍。reducing_gap 可以是 None (不執行第一步) 或應大於 1.0。 reducing_gap 越大，結果越接近公平的重新取樣。reducing_gap 越小，調整大小的速度越快。在大多數情況下，reducing_gap 大於或等於 3.0 時，結果與公平重新取樣沒有區別。預設值為 2.0 (非常接近公平重新取樣，同時在許多情況下速度更快)。

返回:

None

Image.tobitmap(name: str = 'image') → bytes[原始碼]

傳回轉換為 X11 bitmap 的影像。

注意

此方法僅適用於模式 “1” 影像。

參數:

name – 用於 bitmap 變數的名稱前綴。

返回:

包含 X11 bitmap 的字串。

引發:

ValueError – 如果模式不是 “1”

Image.tobytes(encoder_name: str = 'raw', *args: Any) → bytes[原始碼]

以位元組物件形式傳回影像。

警告

此方法會從內部儲存空間傳回原始影像資料。對於壓縮的影像資料（例如 PNG、JPEG），請使用 save()，並使用 BytesIO 參數來處理記憶體中的資料。

參數:

  • encoder_name –

    要使用的編碼器。預設值是使用標準的 "raw" 編碼器。

    C 編碼器的列表可以在 _imaging.c 中函式陣列的編碼器區段中找到。Python 編碼器則是在相關的插件中註冊。

  • args – 編碼器的額外參數。

返回:

一個 bytes 物件。

Image.transform(size: tuple[int, int], method: Transform | ImageTransformHandler | SupportsGetData, data: Sequence[Any] | None = None, resample: int = Resampling.NEAREST, fill: int = 1, fillcolor: float | tuple[float, ...] | str | None = None) → Image[原始碼]

轉換此影像。此方法會建立一個具有指定大小的新影像，且模式與原始影像相同，並使用指定的轉換將資料複製到新影像中。

參數:

  • size – 輸出的像素大小，以 2 元組表示：(寬度, 高度)。

  • method –

    轉換方法。這可以是 Transform.EXTENT （裁剪矩形子區域）、Transform.AFFINE （仿射變換）、Transform.PERSPECTIVE （透視變換）、Transform.QUAD （將四邊形映射到矩形），或 Transform.MESH （在一個操作中映射多個來源四邊形）。

    它也可以是 ImageTransformHandler 物件。

    class Example(Image.ImageTransformHandler):
    def transform(self, size, data, resample, fill=1):
        # Return result

    Transform 方法的某些 ImageTransformHandler 實作可以在 ImageTransform 中找到。

    它也可以是一個具有 method.getdata 方法的物件，該方法返回一個元組，提供新的 method 和 data 值。

    class Example:
    def getdata(self):
        method = Image.Transform.EXTENT
        data = (0, 0, 100, 100)
        return method, data

  • data – 轉換方法的額外資料。

  • resample – 可選的重採樣濾波器。它可以是 Resampling.NEAREST （使用最近鄰）、Resampling.BILINEAR （在 2x2 環境中線性插值）或 Resampling.BICUBIC （在 4x4 環境中三次樣條插值）之一。如果省略，或影像具有 “1” 或 “P” 模式，則將其設定為 Resampling.NEAREST。請參閱：濾波器。

  • fill – 如果 method 是 ImageTransformHandler 物件，則這是傳遞給它的參數之一。否則，它將不會被使用。

  • fillcolor – 輸出影像中轉換區域外部的可選填充顏色。

返回:

Image 物件。

Image.transpose(method: Transpose) → Image[原始碼]

轉置影像（翻轉或以 90 度為單位旋轉）

參數:

method – Transpose.FLIP_LEFT_RIGHT、Transpose.FLIP_TOP_BOTTOM、Transpose.ROTATE_90、Transpose.ROTATE_180、Transpose.ROTATE_270、Transpose.TRANSPOSE 或 Transpose.TRANSVERSE 之一。

返回:

傳回此影像的翻轉或旋轉副本。

此方法會使用 Transpose.FLIP_LEFT_RIGHT 方法翻轉輸入影像。

from PIL import Image

with Image.open("hopper.jpg") as im:

    # Flip the image from left to right
    im_flipped = im.transpose(method=Image.Transpose.FLIP_LEFT_RIGHT)
    # To flip the image from top to bottom,
    # use the method "Image.Transpose.FLIP_TOP_BOTTOM"
Image.verify() → None[原始碼]

驗證檔案的內容。對於從檔案讀取的資料，此方法會嘗試確定檔案是否損壞，而實際上不會解碼影像資料。如果此方法發現任何問題，它會引發適當的例外。如果您在使用此方法後需要載入影像，您必須重新開啟影像檔案。

Image.load() → core.PixelAccess | None[原始碼]

為影像配置儲存空間並載入像素資料。在一般情況下，您不需要呼叫這個方法，因為 Image 類別會在首次存取時自動載入已開啟的影像。

如果與影像關聯的檔案是由 Pillow 開啟的，那麼這個方法將會關閉它。但如果影像是多幀的，則此為例外情況，檔案將保持開啟以進行搜尋操作。有關更多資訊，請參閱Pillow 中的檔案處理。

返回:

影像存取物件。

回傳類型:

PixelAccess

Image.close() → None[原始碼]

如果可以，關閉檔案指標。

此操作將會銷毀影像核心並釋放其記憶體。之後影像資料將無法使用。

此函數是關閉有多個幀或尚未讓 load() 方法讀取並關閉檔案的影像所必需的。有關更多資訊，請參閱Pillow 中的檔案處理。

影像屬性

Image 類別的實例具有以下屬性

Image.filename: str

來源檔案的檔案名稱或路徑。只有使用工廠函數 open 建立的影像才有 filename 屬性。如果輸入是類似檔案的物件，則 filename 屬性會設定為空字串。

Image.format: str | None

來源檔案的檔案格式。對於由程式庫本身建立的影像（透過工廠函數，或透過在現有影像上執行方法），此屬性會設定為 None。

Image.mode: str

影像模式。這是一個字串，指定影像使用的像素格式。常見的值為 “1”、“L”、“RGB” 或 “CMYK”。有關完整清單，請參閱模式。

Image.size: tuple[int]

影像大小，以像素為單位。大小以 2 元組 (寬度, 高度) 表示。

Image.width: int

影像寬度，以像素為單位。

Image.height: int

影像高度，以像素為單位。

Image.palette: PIL.ImagePalette.ImagePalette | None

色彩調色盤表，如果有的話。如果模式為 “P” 或 “PA”，這應該是 ImagePalette 類別的實例。否則，它應該設定為 None。

Image.info: dict

一個字典，保存與影像關聯的資料。此字典由檔案處理常式使用，以傳遞從檔案讀取的各種非影像資訊。有關詳細資訊，請參閱各種檔案處理常式的文件。

大多數方法在返回新影像時會忽略字典；由於鍵未標準化，因此方法無法知道操作是否影響字典。如果您稍後需要資訊，請保留從 open 方法傳回的 info 字典的參考。

除非另有說明，否則此字典不會影響儲存檔案。

Image.is_animated: bool

如果此影像有多個幀，則為 True，否則為 False。

此屬性僅由支援動畫影像的影像外掛程式定義。如果外掛程式不支援載入動畫影像，即使給定的格式支援動畫影像，外掛程式也可能會將此屬性保持未定義。

鑑於此屬性並非適用於所有影像，請使用 getattr(image, "is_animated", False) 來檢查 Pillow 是否知道影像中的多個幀，無論其格式為何。

另請參閱

n_frames、seek() 和 tell()

Image.n_frames: int

此影像中的幀數。

此屬性僅由支援動畫影像的影像外掛程式定義。如果外掛程式不支援載入動畫影像，即使給定的格式支援動畫影像，外掛程式也可能會將此屬性保持未定義。

鑑於此屬性並非適用於所有影像，請使用 getattr(image, "n_frames", 1) 來檢查 Pillow 知道影像中有多少幀，無論其格式為何。

另請參閱

is_animated、seek() 和 tell()

Image.has_transparency_data

確定影像是否具有透明度資料，無論是 alpha 通道的形式、帶有 alpha 通道的調色盤，還是 info 字典中的 “transparency” 鍵。

請注意，如果顯示的所有值都不透明，影像可能仍然顯示為實心的。

返回:

一個布林值。

類別

class PIL.Image.Exif[原始碼]

基底：MutableMapping

此類別提供對 EXIF 影像資料的讀寫權限

from PIL import Image
im = Image.open("exif.png")
exif = im.getexif()  # Returns an instance of this class

可以讀取、寫入、迭代或刪除資訊

print(exif[274])  # 1
exif[274] = 2
for k, v in exif.items():
  print("Tag", k, "Value", v)  # Tag 274 Value 2
del exif[274]

若要存取 IFD0 以外的資訊，get_ifd() 會傳回字典

from PIL import ExifTags
im = Image.open("exif_gps.jpg")
exif = im.getexif()
gps_ifd = exif.get_ifd(ExifTags.IFD.GPSInfo)
print(gps_ifd)

其他 IFD 包括 ExifTags.IFD.Exif、ExifTags.IFD.Makernote、ExifTags.IFD.Interop 和 ExifTags.IFD.IFD1。

ExifTags 也有列舉類別來提供資料的名稱

print(exif[ExifTags.Base.Software])  # PIL
print(gps_ifd[ExifTags.GPS.GPSDateStamp])  # 1999:99:99 99:99:99
bigtiff = False
endian: str | None = None
get_ifd(tag: int) → dict[int, Any][原始碼]
hide_offsets() → None[原始碼]
load(data: bytes) → None[原始碼]
load_from_fp(fp: IO[bytes], offset: int | None = None) → None[原始碼]
tobytes(offset: int = 8) → bytes[原始碼]
class PIL.Image.ImagePointHandler[原始碼]

由點轉換（用於 point()）作為混入使用。

class PIL.Image.ImagePointTransform(scale: float, offset: float)[原始碼]

用於具有超過 8 位元的單波段影像的 point()，此處代表仿射轉換，其中數值乘以 scale 並加上 offset。

class PIL.Image.ImageTransformHandler[原始碼]

由幾何轉換（用於 transform()）作為混入使用。

協定

class PIL.Image.SupportsArrayInterface(*args, **kwargs)[原始碼]

基底類別： Protocol

具有 __array_interface__ 字典的物件。

class PIL.Image.SupportsGetData(*args, **kwargs)[原始碼]

基底類別： Protocol

常數

PIL.Image.NONE
PIL.Image.MAX_IMAGE_PIXELS

設定為 89,478,485，對於 24 位元（3 bpp）影像，約為 0.25GB。有關如何使用此設定的詳細資訊，請參閱 open()。

PIL.Image.WARN_POSSIBLE_FORMATS

設定為 false。如果為 true，當無法識別影像時，嘗試讀取資料的格式會發出警告。

轉置方法

用於指定要使用的 Image.transpose() 方法。

class PIL.Image.Transpose(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[原始碼]
FLIP_LEFT_RIGHT = 0
FLIP_TOP_BOTTOM = 1
ROTATE_180 = 3
ROTATE_270 = 4
ROTATE_90 = 2
TRANSPOSE = 5
TRANSVERSE = 6

轉換方法

用於指定要使用的 Image.transform() 方法。

class PIL.Image.Transform[原始碼]
AFFINE

仿射變換

EXTENT

剪裁出矩形子區域

PERSPECTIVE

透視變換

QUAD

將四邊形映射到矩形

MESH

在一個操作中映射多個來源四邊形

重新取樣濾鏡

詳細資訊請參閱 濾鏡。

class PIL.Image.Resampling(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[原始碼]
BICUBIC = 3
BILINEAR = 2
BOX = 4
HAMMING = 5
LANCZOS = 1
NEAREST = 0

抖動模式

用於指定 convert() 和 quantize() 方法要使用的抖動方法。

class PIL.Image.Dither[原始碼]
NONE

無抖動

ORDERED

未實作

RASTERIZE

未實作

FLOYDSTEINBERG

Floyd-Steinberg 抖動

調色盤

用於指定 convert() 方法要使用的調色盤。

class PIL.Image.Palette(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[原始碼]
ADAPTIVE = 1
WEB = 0

量化方法

用於指定 quantize() 方法要使用的量化方法。

class PIL.Image.Quantize[原始碼]
MEDIANCUT

中位數切割。預設方法，RGBA 影像除外。此方法不支援 RGBA 影像。

MAXCOVERAGE

最大涵蓋率。此方法不支援 RGBA 影像。

FASTOCTREE

快速八叉樹。RGBA 影像的預設方法。

LIBIMAGEQUANT

libimagequant

使用 PIL.features.check_feature() 搭配 feature="libimagequant" 來檢查支援情況。