`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[source]¶

打开并识别给定的图像文件。

这是一个延迟操作；此函数识别文件，但文件保持打开状态，实际的图像数据不会从文件中读取，直到您尝试处理数据（或调用 load() 方法）。参见 new()。参见 Pillow 中的文件处理。

参数：

fp – 文件名（字符串）、os.PathLike 对象或文件对象。文件对象必须实现 file.read、file.seek 和 file.tell 方法，并且以二进制模式打开。文件对象还将在读取之前定位到零。
mode – 模式。如果给出，此参数必须为“r”。
formats – 要尝试加载文件的格式列表或元组。这可以用来限制检查的格式集。传递 None 以尝试所有支持的格式。您可以通过运行 python3 -m PIL 或使用 PIL.features.pilinfo() 函数来打印可用格式集。

返回值：

一个 Image 对象。

异常：

FileNotFoundError – 如果找不到文件。
PIL.UnidentifiedImageError – 如果图像无法打开和识别。
ValueError – 如果 mode 不是“r”，或者如果 StringIO 实例用于 fp。
TypeError – 如果 formats 不是 None、列表或元组。

警告

为了防止由“解压缩炸弹”（即解压缩成大量数据并旨在通过使用大量内存来崩溃或造成中断的恶意文件）造成的潜在 DOS 攻击，Pillow 如果图像中的像素数量超过某个限制，MAX_IMAGE_PIXELS，将发出 DecompressionBombWarning。

可以通过设置 MAX_IMAGE_PIXELS 来更改此阈值。可以通过设置 Image.MAX_IMAGE_PIXELS = None 来禁用它。

如果需要，可以通过 warnings.simplefilter('error', Image.DecompressionBombWarning) 将警告变成错误，或通过 warnings.simplefilter('ignore', Image.DecompressionBombWarning) 完全抑制警告。另见日志记录文档，将警告输出到日志记录工具而不是 stderr。

如果像素数量大于两倍的 MAX_IMAGE_PIXELS，则会引发 DecompressionBombError。

图像处理¶

PIL.Image.alpha_composite(im1: Image, im2: Image) → Image[source]¶

将 im2 以 alpha 混合方式叠加到 im1 上。

参数：

im1 – 第一个图像。必须为 RGBA 模式。
im2 – 第二个图像。必须为 RGBA 模式，并且与第一个图像大小相同。

返回值：

一个 Image 对象。

PIL.Image.blend(im1: Image, im2: Image, alpha: float) → Image[source]¶

使用常数 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[source]¶

使用透明蒙版通过混合图像来创建合成图像。

参数：

image1 – 第一个图像。
image2 – 第二个图像。必须与第一个图像具有相同的模式和大小。
mask – 蒙版图像。此图像可以具有“1”，“L”或“RGBA”模式，并且必须与其他两个图像具有相同的大小。

PIL.Image.eval(image: Image, *args: Callable[[int], float]) → Image[source]¶

将函数（应该接受一个参数）应用于给定图像中的每个像素。如果图像具有多个波段，则将相同函数应用于每个波段。请注意，该函数针对每个可能的像素值评估一次，因此您无法使用随机组件或其他生成器。

参数：

image – 输入图像。
function – 函数对象，接受一个整型参数。

返回值：

一个 Image 对象。

PIL.Image.merge(mode: str, bands: Sequence[Image]) → Image[source]¶

将一组单波段图像合并到一个新的多波段图像中。

参数：

mode – 要用于输出图像的模式。参见：Modes.
bands – 一个序列，包含输出图像中每个波段的一个单波段图像。所有波段必须具有相同的大小。

返回值：

一个 Image 对象。

构造图像¶

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

使用给定的模式和大小创建一个新图像。

参数：

mode – 要用于新图像的模式。参见：Modes.
size – 一个 2 元组，包含以像素为单位的 (宽度, 高度)。
color – 用于图像的颜色。默认值为黑色。如果给出，则对于单波段模式，这应该是一个单个整数或浮点数，对于多波段模式，这应该是一个元组（每个波段一个值）。在创建 RGB 或 HSV 图像时，您还可以使用 ImageColor 模块支持的颜色字符串。如果颜色为 None，则图像不会初始化。

返回值：

一个 Image 对象。

PIL.Image.fromarray(obj: SupportsArrayInterface, mode: str | None = None) → Image[source]¶

从导出数组接口（使用缓冲区协议）的对象创建图像内存。

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

如果 obj 不连续，则调用 tobytes 方法，并使用 frombuffer()。

在 NumPy 的情况下，请注意 Pillow 模式并不总是对应于 NumPy 数据类型。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[source]¶

从缓冲区中的像素数据创建图像内存的副本。

最简单形式下，此函数需要三个参数（模式、大小和解包后的像素数据）。

您还可以使用 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[source]¶

创建一个引用字节缓冲区中像素数据的图像内存。

此函数类似于 frombytes()，但使用字节缓冲区中的数据（如果可能）。这意味着对原始缓冲区对象的更改会反映在此图像中）。并非所有模式都可以共享内存；支持的模式包括“L”、“RGBX”、“RGBA”和“CMYK”。

请注意，此函数仅解码像素数据，而不是整个图像。如果您有一个字符串中的整个图像文件，请将其包装在 BytesIO 对象中，并使用 open() 加载它。

用于“raw”解码器的默认参数与用于 frombytes() 的参数不同。这是一个 bug，可能会在将来的版本中修复。当前版本在您这样做时会发出警告；要禁用警告，您应该提供完整参数集。有关详细信息，请参见下文。

参数：

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[source]¶

生成覆盖给定范围的曼德布洛特集合。

参数：

size – 以 2 元组表示的请求大小（以像素为单位）：(宽度，高度)。
extent – 以 4 元组表示的覆盖范围：(x0，y0，x1，y1)。
quality – 质量。

PIL.Image.effect_noise(size: tuple[int, int], sigma: float) → Image[source]¶

生成以 128 为中心的的正态噪声。

参数：

size – 以 2 元组表示的请求大小（以像素为单位）：(宽度，高度)。
sigma – 噪声的标准差。

PIL.Image.linear_gradient(mode: str) → Image[source]¶

生成从黑色到白色的 256x256 线性渐变，从上到下。

参数：: mode – 输入模式。

PIL.Image.radial_gradient(mode: str) → Image[source]¶

生成 256x256 从黑色到白色的径向渐变，从中心到边缘。

参数：: mode – 输入模式。

注册插件¶

PIL.Image.preinit() → None[source]¶

显式加载 BMP、GIF、JPEG、PPM 和 PPM 文件格式驱动程序。

在打开或保存图像时调用。

PIL.Image.init() → bool[source]¶

显式初始化 Python 图像库。此函数加载所有可用的文件格式驱动程序。

如果 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[source]¶

注册图像文件插件。此函数不应在应用程序代码中使用。

参数：

id – 图像格式标识符。
factory – 图像文件工厂方法。
accept – 可用于快速拒绝具有其他格式的图像的可选函数。

PIL.Image.register_mime(id: str, mimetype: str) → None[source]¶

通过填充 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[source]¶

注册图像保存函数。此函数不应在应用程序代码中使用。

参数：

id – 图像格式标识符。
driver – 以此格式保存图像的函数。

PIL.Image.register_save_all(id: str, driver: Callable[[Image, IO[bytes], str | bytes], None]) → None[source]¶

注册一个图像函数来保存多帧格式的所有帧。此函数不应在应用程序代码中使用。

参数：

id – 图像格式标识符。
driver – 以此格式保存图像的函数。

PIL.Image.register_extension(id: str, extension: str) → None[source]¶

注册图像扩展名。此函数不应在应用程序代码中使用。

参数：

id – 图像格式标识符。
extension – 此格式使用的扩展名。

PIL.Image.register_extensions(id: str, extensions: list[str]) → None[source]¶

注册图像扩展名。此函数不应在应用程序代码中使用。

参数：

id – 图像格式标识符。
extensions – 此格式使用的扩展名列表。

PIL.Image.registered_extensions() → dict[str, str][source]¶: 返回一个字典，包含所有属于已注册插件的文件扩展名。

PIL.Image.register_decoder(name: str, decoder: type[ImageFile.PyDecoder]) → None[source]¶

注册图像解码器。此函数不应在应用程序代码中使用。

参数：

name – 解码器的名称
decoder – 一个 ImageFile.PyDecoder 对象

添加到版本 4.1.0 中。

PIL.Image.register_encoder(name: str, encoder: type[ImageFile.PyEncoder]) → None[source]¶

注册图像编码器。此函数不应在应用程序代码中使用。

参数：

name – 编码器的名称
encoder – 一个 ImageFile.PyEncoder 对象

添加到版本 4.1.0 中。

图像类¶

class PIL.Image.Image[source]¶

此类表示一个图像对象。要创建 Image 对象，请使用相应的工厂函数。几乎没有理由直接调用 Image 构造函数。

open()
new()
frombytes()

一个 Image 类的实例具有以下方法。除非另有说明，否则所有方法都返回一个新的 Image 类的实例，包含结果图像。

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

Image.alpha_composite 的“就地”模拟。将一个图像合成到此图像上。

参数：

im – 要在此图像上合成的图像
dest – 可选的 2 元组 (left, top)，指定此（目标）图像中的左上角。
source – 可选的 2 元组 (left, top)，用于覆盖源图像中的左上角，或 4 元组 (left, top, right, bottom)，用于源矩形的边界

性能说明：当前在核心层中未就地实现。

Image.apply_transparency() → None[source]¶: 如果 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[source]¶

返回此图像的转换副本。对于“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[source]¶

复制此图像。如果您希望将内容粘贴到图像中，但仍保留原始图像，请使用此方法。

返回类型:: Image
返回值：: 一个 Image 对象。

Image.crop(box: tuple[float, float, float, float] | None = None) → Image[source]¶

返回此图像的矩形区域。box 是一个 4 元组，定义了左、上、右和下像素坐标。请参阅坐标系.

注意：在 Pillow 3.4.0 之前，这是一个延迟操作。

参数：: box – 裁剪矩形，以 (left, upper, right, lower) 元组形式给出。
返回类型:: 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[source]¶

配置图像文件加载器，以便它返回尽可能接近给定模式和大小的图像版本。例如，您可以使用此方法在加载时将彩色 JPEG 转换为灰度。

如果进行了任何更改，则返回一个元组，其中包含所选的 mode 和 box，其中包含原始图像在修改后的图像中的坐标。

请注意，此方法会就地修改 Image 对象。如果图像已经加载，此方法将无效。

注意：此方法尚未在大多数图像上实现。目前仅针对 JPEG 和 MPO 图像实现。

参数：

mode – 所需模式。
size – 以 2 元组表示的请求大小（以像素为单位）：(宽度，高度)。

Image.effect_spread(distance: int) → Image[source]¶

随机散布图像中的像素。

参数：: distance – 散布像素的距离。

Image.entropy(mask: Image | None = None, extrema: tuple[float, float] | None = None) → float[source]¶

计算并返回图像的熵。

双色调图像（模式“1”）由此方法视为灰度图像（“L”）。

如果提供了蒙版，则该方法将使用蒙版图像非零部分的直方图。蒙版图像的大小必须与图像相同，并且必须是双色调图像（模式“1”）或灰度图像（“L”）。

参数：

mask – 可选蒙版。
extrema – 可选的，手动指定的极值元组。

返回值：

表示图像熵的浮点值

Image.filter(filter: ImageFilter.Filter | type[ImageFilter.Filter]) → Image[source]¶

使用给定的滤镜对该图像进行滤波。有关可用滤镜的列表，请参见 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[source]¶

使用字节对象中的像素数据加载此图像。

此方法类似于 frombytes() 函数，但将数据加载到此图像中，而不是创建新的图像对象。

Image.getbands() → tuple[str, ...][source]¶

返回一个元组，其中包含此图像中每个波段的名称。例如，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[source]¶

计算图像中非零区域的边界框。

参数：: 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[source]¶

返回包含源图像单个通道的图像。

参数：: 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[source]¶

返回图像中使用的颜色列表。

颜色将以图像的模式显示。例如，RGB 图像将返回一个包含 (red, green, blue) 颜色值的元组，而 P 图像将返回调色板中颜色的索引。

参数：: maxcolors – 最大颜色数。如果超过此数量，该方法将返回 None。默认限制为 256 种颜色。
返回值：: 一个包含 (count, pixel) 值的无序列表。

Image.getdata(band: int | None = None) → core.ImagingCore[source]¶

将图像内容作为包含像素值的序列对象返回。序列对象是扁平化的，因此第 1 行的值紧随第 0 行的值，以此类推。

请注意，此方法返回的序列对象是 PIL 内部数据类型，它只支持某些序列操作。要将其转换为普通序列（例如，用于打印），请使用 list(im.getdata())。

参数：: band – 要返回的波段。默认值为返回所有波段。要返回单个波段，请传入索引值（例如，0 表示从“RGB”图像获取“R”波段）。
返回值：: 类似序列的对象。

Image.getexif() → Exif[source]¶

从图像获取 EXIF 数据。

返回值：: 一个 Exif 对象。

Image.getextrema() → tuple[float, float] | tuple[tuple[int, int], ...][source]¶

获取图像中每个波段的最小和最大像素值。

返回值：: 对于单波段图像，一个包含最小和最大像素值的 2 元组。对于多波段图像，一个包含每个波段的一个 2 元组的元组。

Image.getpalette(rawmode: str | None = 'RGB') → list[int] | None[source]¶

以列表形式返回图像调色板。

参数：

rawmode –

返回调色板的模式。 None 将以其当前模式返回调色板。

在版本 9.1.0 中添加。

返回值：

一个颜色值列表 [r, g, b, …]，如果图像没有调色板，则为 None。

Image.getpixel(xy: tuple[int, int] | list[int]) → float | tuple[int, ...] | None[source]¶

返回给定位置的像素值。

参数：: xy – 坐标，表示为 (x, y)。请参见坐标系.
返回值：: 像素值。如果图像为多层图像，则此方法将返回一个元组。

Image.getprojection() → tuple[list[int], list[int]][source]¶

获取 X 轴和 Y 轴的投影

返回值：: 两个序列，分别表示 X 轴和 Y 轴上非零像素的位置。

Image.getxmp() → dict[str, Any][source]¶

返回一个包含 XMP 标记的字典。需要安装 defusedxml。

返回值：: 字典中的 XMP 标记。

Image.histogram(mask: Image | None = None, extrema: tuple[float, float] | None = None) → list[int][source]¶

返回图像的直方图。直方图以像素计数列表的形式返回，每个像素值对应源图像中的一个像素计数。计数被分组到每个波段的 256 个 bin 中，即使图像每个波段超过 8 位也是如此。如果图像有多个波段，则所有波段的直方图将被连接起来（例如，“RGB”图像的直方图包含 768 个值）。

双色调图像（模式“1”）由此方法视为灰度图像（“L”）。

如果提供了一个蒙版，该方法将返回图像中蒙版图像非零部分的直方图。蒙版图像必须与图像具有相同的大小，并且是双层图像（模式“1”）或灰度图像（“L”）。

参数：

mask – 可选蒙版。
extrema – 可选的，手动指定的极值元组。

返回值：

包含像素计数的列表。

将另一张图像粘贴到此图像中。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 – 可选的蒙版图像。

将此图像映射到查找表或函数。

参数：

lut –
查找表，包含图像中每个波段的 256 个（或 65536 个，如果 self.mode ==“I”且 mode ==“L”）值。可以使用函数代替，它应该接受一个参数。对每个可能的像素值调用一次函数，并将生成的表应用于图像的所有波段。

它也可以是 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[source]¶

在图像中添加或替换 alpha 通道。如果图像没有 alpha 通道，则将其转换为“LA”或“RGBA”。新的 alpha 通道必须是“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[source]¶

将像素数据从扁平化的序列对象复制到图像中。数据应从左上角 (0, 0) 开始，一直到行的末尾，然后紧接第二行的第一个值，依此类推。数据将持续读取，直到图像或序列结束。比例和偏移值用于调整序列值：像素 = 值*比例 + 偏移。

参数：

data – 扁平化的序列对象。
scale – 可选的比例值。默认值为 1.0。
offset – 可选的偏移值。默认值为 0.0。

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

将调色板附加到图像。图像必须是“P”、“PA”、“L”或“LA”图像。

调色板序列最多包含 256 种颜色，每种颜色由 raw 模式中每个通道的一个整数值组成。例如，如果 raw 模式为“RGB”，则它最多包含 768 个值，构成 256 种颜色中相应像素索引的红色、绿色和蓝色值。如果 raw 模式为“RGBA”，则它最多包含 1024 个值，包含红色、绿色、蓝色和 alpha 值。

或者，可以使用 8 位字符串代替整数序列。

参数：

data – 调色板序列（列表或字符串）。
rawmode – 调色板的 raw 模式。可以是“RGB”、“RGBA”，或者可以转换为“RGB”或“RGBA”的模式（例如“R”、“BGR;15”、“RGBA;L”）。

Image.putpixel(xy: tuple[int, int], value: float | tuple[int, ...] | list[int]) → None[source]¶

修改给定位置的像素。颜色对于单波段图像使用单个数值表示，对于多波段图像使用元组表示。此外，对于 P 和 PA 图像，还接受 RGB 和 RGBA 元组。

请注意，此方法相对较慢。对于更广泛的更改，请使用 paste() 或 ImageDraw 模块。

参见

paste()
putdata()
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[source]¶

将图像转换为使用指定颜色数量的‘P’模式。

参数：

colors – 需要的颜色数量，<= 256
method –
Quantize.MEDIANCUT (中值切割法), Quantize.MAXCOVERAGE (最大覆盖法), Quantize.FASTOCTREE (快速八叉树), Quantize.LIBIMAGEQUANT (libimagequant; 使用 PIL.features.check_feature() 和 feature="libimagequant" 检查支持情况).

默认情况下，将使用 Quantize.MEDIANCUT。

RGBA 图像除外。 Quantize.MEDIANCUT 和 Quantize.MAXCOVERAGE 不支持 RGBA 图像，因此默认情况下使用 Quantize.FASTOCTREE。
kmeans – 大于或等于零的整数。
palette – 量化为给定 PIL.Image.Image 的调色板。
dither – 抖动方法，在从模式“RGB”转换为“P”或从“RGB”或“L”转换为“1”时使用。可用方法为 Dither.NONE 或 Dither.FLOYDSTEINBERG （默认）。

返回值：

一个新的图像

Image.reduce(factor: int | tuple[int, int], box: tuple[int, int, int, int] | None = None) → Image[source]¶

返回图像缩小 factor 倍后的副本。如果图像大小不能被 factor 整除，则最终大小将向上取整。

参数：

factor – 大于 0 的整数或包含两个整数的元组，分别表示宽度和高度。
box – 包含四个整数的元组，可选，表示要缩小的源图像区域。值必须位于 (0, 0, width, height) 矩形内。如果省略或为 None，则使用整个源图像。

Image.remap_palette(dest_map: list[int], source_palette: bytes | bytearray | None = None) → Image[source]¶

重写图像以重新排序调色板。

参数：

dest_map – 指向原始调色板的索引列表。例如， [1,0] 将交换两个项目调色板，而 list(range(256)) 是标识转换。
source_palette – 字节或 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。参见：Filters.
box – 可选的 4 元组浮点数，提供要缩放的源图像区域。这些值必须在 (0, 0, 宽度, 高度) 矩形内。如果省略或为 None，则使用整个源图像。
reducing_gap – 使用两步对图像进行调整大小以进行优化。首先，使用 reduce() 将图像按整数倍缩小。其次，使用常规重采样调整大小。最后一步将大小至少更改 reducing_gap 倍。reducing_gap 可以是 None（不执行第一步）或大于 1.0。reducing_gap 越大，结果越接近公平重采样。reducing_gap 越小，调整大小的速度越快。当 reducing_gap 大于或等于 3.0 时，在大多数情况下，结果与公平重采样无法区分。默认值为 None（没有优化）。

返回值：

一个 Image 对象。

这将给定图像从 (宽度, 高度) 调整大小到 (宽度/2, 高度/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))

返回此图像的旋转副本。此方法返回此图像的副本，以给定的度数逆时针绕其中心旋转。

参数：

angle – 逆时针方向以度为单位。
resample – 可选的重采样滤波器。它可以是以下之一：Resampling.NEAREST（使用最近邻）、Resampling.BILINEAR（2x2 环境中的线性插值）或 Resampling.BICUBIC（4x4 环境中的三次样条插值）。如果省略，或如果图像模式为“1”或“P”，则设置为 Resampling.NEAREST。参见 Filters.
expand – 可选的扩展标志。如果为真，则扩展输出图像以使其足够大以容纳整个旋转图像。如果为假或省略，则使输出图像与输入图像大小相同。请注意，扩展标志假定绕中心旋转，没有平移。
center – 可选的旋转中心（2 元组）。原点是左上角。默认为图像中心。
translate – 可选的旋转后平移（2 元组）。
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[source]¶

将此图像保存到给定的文件名下。如果未指定格式，则尽可能从文件名扩展名确定要使用的格式。

关键字选项可用于向写入器提供其他说明。如果写入器不识别某个选项，则会静默忽略它。可用选项在每个写入器的图像格式文档中进行了描述。

可以使用文件对象而不是文件名。在这种情况下，必须始终指定格式。文件对象必须实现 seek、tell 和 write 方法，并且必须以二进制模式打开。

参数：

fp – 文件名（字符串）、os.PathLike 对象或文件对象。
format – 可选的格式覆盖。如果省略，则从文件名扩展名确定要使用的格式。如果使用了文件对象而不是文件名，则应始终使用此参数。
params – 传递给图像写入器的额外参数。

返回值：

None

异常：

ValueError – 如果无法从文件名确定输出格式。使用 format 选项解决此问题。
OSError – 如果无法写入文件。文件可能已创建，并且可能包含部分数据。

Image.seek(frame: int) → None[source]¶

将此序列文件中的指针移动到给定的帧。如果超出序列的末尾，该方法将引发 EOFError 异常。打开序列文件时，库会自动将指针移动到帧 0。

参见 tell()。

如果已定义，n_frames 指的是可用帧的数量。

参数：: frame – 帧号，从 0 开始。
异常：: EOFError – 如果调用尝试将指针移动到序列的末尾以外。

Image.show(title: str | None = None) → None[source]¶

显示此图像。此方法主要用于调试目的。

此方法在内部调用 PIL.ImageShow.show()。可以使用 PIL.ImageShow.register() 覆盖其默认行为。

图像首先保存到一个临时文件。默认情况下，它将使用 PNG 格式。

在 Unix 上，图像将使用 xdg-open、display、gm、eog 或 xv 实用程序打开，具体取决于可以找到哪一个。

在 macOS 上，图像将使用本机预览应用程序打开。

在 Windows 上，图像将使用标准 PNG 显示实用程序打开。

参数：: title – 可选标题，用于图像窗口（如果可能）。

Image.split() → tuple[Image, ...][source]¶

将此图像拆分为单独的波段。此方法从图像中返回一个包含单独图像波段的元组。例如，拆分“RGB”图像会创建三个新图像，每个图像都包含原始波段之一的副本（红色、绿色、蓝色）。

如果您只需要一个波段，getchannel() 方法可能更方便快捷。

返回值：: 包含波段的元组。

Image.tell() → int[source]¶

返回当前帧号。参见 seek()。

如果已定义，n_frames 指的是可用帧的数量。

返回值：: 帧号，从 0 开始。

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

将此图像缩略图化。此方法修改图像，使其包含自身缩略图版本，不超过给定的尺寸。此方法计算适当的缩略图尺寸以保留图像的纵横比，调用 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[source]¶

返回转换为 X11 位图的图像。

注意

此方法仅适用于模式“1”图像。

参数：: name – 用于位图变量的名称前缀。
返回值：: 包含 X11 位图的字符串。
异常：: ValueError – 如果模式不是“1”

Image.tobytes(encoder_name: str = 'raw', *args: Any) → bytes[source]¶

将图像作为字节对象返回。

警告

此方法返回内部存储中的原始图像数据。对于压缩图像数据（例如 PNG、JPEG），请使用 save()，并使用 BytesIO 参数进行内存中数据。

参数：

encoder_name –
要使用的编码器。默认情况下，使用标准“raw”编码器。

可以在 _imaging.c 中的函数数组的 codecs 部分中看到 C 编码器的列表。Python 编码器在相关的插件中注册。
args – 传递给编码器的额外参数。

返回值：

一个 bytes 对象。

变换此图像。此方法使用给定的变换创建具有给定大小和与原始图像相同模式的新图像，并将数据复制到新图像。

参数：

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
```
在 ImageTransform 中提供了一些 Transform 方法的 ImageTransformHandler 实现。

它也可以是具有 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[source]¶

转置图像（以 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[source]¶: 验证文件内容。对于从文件读取的数据，此方法尝试确定文件是否损坏，而无需实际解码图像数据。如果此方法发现任何问题，它将引发合适的异常。如果您需要在使用此方法后加载图像，则必须重新打开图像文件。

Image.load() → core.PixelAccess | None[source]¶

为图像分配存储空间并加载像素数据。在正常情况下，您不需要调用此方法，因为 Image 类在首次访问时会自动加载打开的图像。

如果与图像关联的文件是由 Pillow 打开的，那么此方法将关闭它。例外情况是，如果图像具有多个帧，在这种情况下，文件将保持打开状态以进行查找操作。有关更多信息，请参阅 Pillow 中的文件处理。

返回值：: 一个图像访问对象。
返回类型:: PixelAccess

Image.close() → None[source]¶

如果可能，关闭文件指针。

此操作将销毁图像核心并释放其内存。图像数据之后将无法使用。

此函数用于关闭具有多个帧或其文件尚未由 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[source]¶

Bases: 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][source]¶

hide_offsets() → None[source]¶

load(data: bytes) → None[source]¶

load_from_fp(fp: IO[bytes], offset: int | None = None) → None[source]¶

tobytes(offset: int = 8) → bytes[source]¶

class PIL.Image.ImagePointHandler[source]¶: 用于点变换的混合类（用于 point()）

class PIL.Image.ImagePointTransform(scale: float, offset: float)[source]¶: 与 point() 一起用于具有 8 位以上单通道图像，表示仿射变换，其中值乘以 scale 并添加 offset。

class PIL.Image.ImageTransformHandler[source]¶: 用于几何变换的混合类（用于 transform()）

协议¶

class PIL.Image.SupportsArrayInterface(*args, **kwargs)[source]¶

Bases: Protocol

具有 __array_interface__ 字典的对象。

class PIL.Image.SupportsGetData(*args, **kwargs)[source]¶: Bases: 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)[source]¶

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[source]¶

AFFINE¶: 仿射变换

EXTENT¶: 裁剪矩形子区域

PERSPECTIVE¶: 透视变换

QUAD¶: 将四边形映射到矩形

MESH¶: 一次操作映射多个源四边形

重采样滤波器¶

有关详细信息，请参见滤波器。

class PIL.Image.Resampling(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]¶

BICUBIC = 3¶

BILINEAR = 2¶

BOX = 4¶

HAMMING = 5¶

LANCZOS = 1¶

NEAREST = 0¶

抖动模式¶

用于为 convert() 和 quantize() 方法指定要使用的抖动方法。

class PIL.Image.Dither[source]¶

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)[source]¶

ADAPTIVE = 1¶

WEB = 0¶

量化方法¶

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

class PIL.Image.Quantize[source]¶

MEDIANCUT¶: 中值切割。默认方法，但 RGBA 图像除外。此方法不支持 RGBA 图像。

MAXCOVERAGE¶: 最大覆盖率。此方法不支持 RGBA 图像。

FASTOCTREE¶: 快速八叉树。RGBA 图像的默认方法。

LIBIMAGEQUANT¶

libimagequant

使用 PIL.features.check_feature() 和 feature="libimagequant" 检查支持情况。

Image 模块¶

示例¶

打开、旋转并显示图像（使用默认查看器）¶

创建缩略图¶

函数¶

图像处理¶

构造图像¶

生成图像¶

注册插件¶

图像类¶

图像属性¶

类¶

协议¶

常量¶

转置方法¶

变换方法¶

重采样滤波器¶

抖动模式¶

调色板¶

量化方法¶

`Image` 模块¶