Pillow学习之Image类（一）

时间不早了，上个类的解释文档吧

>>> from PIL import Image

>>> im = Image.open(‘1.jpg’)

>>> help(im)

Help on JpegImageFile in module PIL.JpegImagePlugin object:

class JpegImageFile(PIL.ImageFile.ImageFile)

| Base class for image file format handlers.

|

| Method resolution order:

| JpegImageFile

| PIL.ImageFile.ImageFile

| PIL.Image.Image

| builtins.object

|

| Methods defined here:

|

| draft(self, mode, size)

| Set draft mode

|

| load_djpeg(self)

|

| ———————————————————————-

| Data and other attributes defined here:

|

| format = ‘JPEG’

|

| format_description = ‘JPEG (ISO 10918)’

|

| ———————————————————————-

| Methods inherited from PIL.ImageFile.ImageFile:

|

| init(self, fp=None, filename=None)

| Initialize self. See help(type(self)) for accurate signature.

|

| load(self)

| Load image data based on tile list

|

| load_end(self)

|

| load_prepare(self)

|

| verify(self)

| Check file integrity

|

| ———————————————————————-

| Methods inherited from PIL.Image.Image:

|

| copy = copy(self)

| Copies this image. Use this method if you wish to paste things

| into an image, but still retain the original.

|

| :rtype: :py:class:

~PIL.Image.Image

| :returns: An :py:class:

~PIL.Image.Image

object.

|

| enter(self)

| # Context Manager Support

|

| eq(self, other)

| Return self==value.

|

| exit(self, *args)

|

| getstate(self)

|

| ne(self, other)

| Return self!=value.

|

| repr(self)

| Return repr(self).

|

| setstate(self, state)

|

| close(self)

| Closes the file pointer, if possible.

|

| This operation will destroy the image core and release its memory.

| The image data will be unusable afterward.

|

| This function is only required to close images that have not

| had their file read and closed by the

| :py:meth:

~PIL.Image.Image.load

method.

|

| convert(self, mode=None, matrix=None, dither=None, palette=0, colors=256)

| Returns a converted copy of this image. For the “P” mode, this

| method translates pixels through the palette. If mode is

| omitted, a mode is chosen so that all information in the image

| and the palette can be represented without a palette.

|

| The current version supports all possible conversions between

| “L”, “RGB” and “CMYK.” The matrix argument only supports “L”

| and “RGB”.

|

| When translating a color image to black and white (mode “L”),

| the library uses the ITU-R 601-2 luma transform::

|

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

|

| The default method of converting a greyscale (“L”) or “RGB”

| image into a bilevel (mode “1”) image uses Floyd-Steinberg

| dither to approximate the original image luminosity levels. If

| dither is NONE, all non-zero values are set to 255 (white). To

| use other thresholds, use the :py:meth:

~PIL.Image.Image.point

| method.

|

| :param mode: The requested mode. See: :ref:

concept-modes

.

| :param matrix: An optional conversion matrix. If given, this

| should be 4- or 12-tuple containing floating point values.

| :param dither: Dithering method, used when converting from

| mode “RGB” to “P” or from “RGB” or “L” to “1”.

| Available methods are NONE or FLOYDSTEINBERG (default).

| :param palette: Palette to use when converting from mode “RGB”

| to “P”. Available palettes are WEB or ADAPTIVE.

| :param colors: Number of colors to use for the ADAPTIVE palette.

| Defaults to 256.

| :rtype: :py:class:

~PIL.Image.Image

| :returns: An :py:class:

~PIL.Image.Image

object.

|

| copy(self)

| Copies this image. Use this method if you wish to paste things

| into an image, but still retain the original.

|

| :rtype: :py:class:

~PIL.Image.Image

| :returns: An :py:class:

~PIL.Image.Image

object.

|

| crop(self, box=None)

| Returns a rectangular region from this image. The box is a

| 4-tuple defining the left, upper, right, and lower pixel

| coordinate.

|

| Note: Prior to Pillow 3.4.0, this was a lazy operation.

|

| :param box: The crop rectangle, as a (left, upper, right, lower)-tuple.

| :rtype: :py:class:

~PIL.Image.Image

| :returns: An :py:class:

~PIL.Image.Image

object.

|

| effect_spread(self, distance)

| Randomly spread pixels in an image.

|

| :param distance: Distance to spread pixels.

|

| filter(self, filter)

| Filters this image using the given filter. For a list of

| available filters, see the :py:mod:

~PIL.ImageFilter

module.

|

| :param filter: Filter kernel.

| :returns: An :py:class:

~PIL.Image.Image

object.

|

| frombytes(self, data, decoder_name=’raw’, *args)

| Loads this image with pixel data from a bytes object.

|

| This method is similar to the :py:func:

~PIL.Image.frombytes

function,

| but loads data into this image instead of creating a new image object.

|

| fromstring(self, *args, **kw)

|

| getbands(self)

| Returns a tuple containing the name of each band in this image.

| For example, getbands on an RGB image returns (“R”, “G”, “B”).

|

| :returns: A tuple containing band names.

| :rtype: tuple

|

| getbbox(self)

| Calculates the bounding box of the non-zero regions in the

| image.

|

| :returns: The bounding box is returned as a 4-tuple defining the

| left, upper, right, and lower pixel coordinate. If the image

| is completely empty, this method returns None.

|

| getcolors(self, maxcolors=256)

| Returns a list of colors used in this image.

|

| :param maxcolors: Maximum number of colors. If this number is

| exceeded, this method returns None. The default limit is

| 256 colors.

| :returns: An unsorted list of (count, pixel) values.

|

| getdata(self, band=None)

| Returns the contents of this image as a sequence object

| containing pixel values. The sequence object is flattened, so

| that values for line one follow directly after the values of

| line zero, and so on.

|

| Note that the sequence object returned by this method is an

| internal PIL data type, which only supports certain sequence

| operations. To convert it to an ordinary sequence (e.g. for

| printing), use list(im.getdata()).

|

| :param band: What band to return. The default is to return

| all bands. To return a single band, pass in the index

| value (e.g. 0 to get the “R” band from an “RGB” image).

| :returns: A sequence-like object.

|

| getextrema(self)

| Gets the the minimum and maximum pixel values for each band in

| the image.

|

| :returns: For a single-band image, a 2-tuple containing the

| minimum and maximum pixel value. For a multi-band image,

| a tuple containing one 2-tuple for each band.

|

| getim(self)

| Returns a capsule that points to the internal image memory.

|

| :returns: A capsule object.

|

| getpalette(self)

| Returns the image palette as a list.

|

| :returns: A list of color values [r, g, b, …], or None if the

| image has no palette.

|

| getpixel(self, xy)

| Returns the pixel value at a given position.

|

| :param xy: The coordinate, given as (x, y).

| :returns: The pixel value. If the image is a multi-layer image,

| this method returns a tuple.

|

| getprojection(self)

| Get projection to x and y axes

|

| :returns: Two sequences, indicating where there are non-zero

| pixels along the X-axis and the Y-axis, respectively.

|

| histogram(self, mask=None, extrema=None)

| Returns a histogram for the image. The histogram is returned as

| a list of pixel counts, one for each pixel value in the source

| image. If the image has more than one band, the histograms for

| all bands are concatenated (for example, the histogram for an

| “RGB” image contains 768 values).

|

| A bilevel image (mode “1”) is treated as a greyscale (“L”) image

| by this method.

|

| If a mask is provided, the method returns a histogram for those

| parts of the image where the mask image is non-zero. The mask

| image must have the same size as the image, and be either a

| bi-level image (mode “1”) or a greyscale image (“L”).

|

| :param mask: An optional mask.

| :returns: A list containing pixel counts.

|

| offset(self, xoffset, yoffset=None)

|

| paste(self, im, box=None, mask=None)

| Pastes another image into this image. The box argument is either

| a 2-tuple giving the upper left corner, a 4-tuple defining the

| left, upper, right, and lower pixel coordinate, or None (same as

| (0, 0)). If a 4-tuple is given, the size of the pasted image

| must match the size of the region.

|

| If the modes don’t match, the pasted image is converted to the mode of

| this image (see the :py:meth:

~PIL.Image.Image.convert

method for

| details).

|

| Instead of an image, the source can be a integer or tuple

| containing pixel values. The method then fills the region

| with the given color. When creating RGB images, you can

| also use color strings as supported by the ImageColor module.

|

| If a mask is given, this method updates only the regions

| indicated by the mask. You can use either “1”, “L” or “RGBA”

| images (in the latter case, the alpha band is used as mask).

| Where the mask is 255, the given image is copied as is. Where

| the mask is 0, the current value is preserved. Intermediate

| values will mix the two images together, including their alpha

| channels if they have them.

|

| See :py:meth:

~PIL.Image.Image.alpha_composite

if you want to

| combine images with respect to their alpha channels.

|

| :param im: Source image or pixel value (integer or tuple).

| :param box: An optional 4-tuple giving the region to paste into.

| If a 2-tuple is used instead, it’s treated as the upper left

| corner. If omitted or None, the source is pasted into the

| upper left corner.

|

| If an image is given as the second argument and there is no

| third, the box defaults to (0, 0), and the second argument

| is interpreted as a mask image.

| :param mask: An optional mask image.

|

| point(self, lut, mode=None)

| Maps this image through a lookup table or function.

|

| :param lut: A lookup table, containing 256 (or 65336 if

| self.mode==”I” and mode == “L”) values per band in the

| image. A function can be used instead, it should take a

| single argument. The function is called once for each

| possible pixel value, and the resulting table is applied to

| all bands of the image.

| :param mode: Output mode (default is same as input). In the

| current version, this can only be used if the source image

| has mode “L” or “P”, and the output has mode “1” or the

| source image mode is “I” and the output mode is “L”.

| :returns: An :py:class:

~PIL.Image.Image

object.

|

| putalpha(self, alpha)

| Adds or replaces the alpha layer in this image. If the image

| does not have an alpha layer, it’s converted to “LA” or “RGBA”.

| The new layer must be either “L” or “1”.

|

| :param alpha: The new alpha layer. This can either be an “L” or “1”

| image having the same size as this image, or an integer or

| other color value.

|

| putdata(self, data, scale=1.0, offset=0.0)

| Copies pixel data to this image. This method copies data from a

| sequence object into the image, starting at the upper left

| corner (0, 0), and continuing until either the image or the

| sequence ends. The scale and offset values are used to adjust

| the sequence values: pixel = value*scale + offset.

|

| :param data: A sequence object.

| :param scale: An optional scale value. The default is 1.0.

| :param offset: An optional offset value. The default is 0.0.

|

| putpalette(self, data, rawmode=’RGB’)

| Attaches a palette to this image. The image must be a “P” or

| “L” image, and the palette sequence must contain 768 integer

| values, where each group of three values represent the red,

| green, and blue values for the corresponding pixel

| index. Instead of an integer sequence, you can use an 8-bit

| string.

|

| :param data: A palette sequence (either a list or a string).

|

| putpixel(self, xy, value)

| Modifies the pixel at the given position. The color is given as

| a single numerical value for single-band images, and a tuple for

| multi-band images.

|

| Note that this method is relatively slow. For more extensive changes,

| use :py:meth:

~PIL.Image.Image.paste

or the :py:mod:

~PIL.ImageDraw

| module instead.

|

| See:

|

| * :py:meth:

~PIL.Image.Image.paste

| * :py:meth:

~PIL.Image.Image.putdata

| * :py:mod:

~PIL.ImageDraw

|

| :param xy: The pixel coordinate, given as (x, y).

| :param value: The pixel value.

|

| quantize(self, colors=256, method=None, kmeans=0, palette=None)

| Convert the image to ‘P’ mode with the specified number

| of colors.

|

| :param colors: The desired number of colors, <= 256

| :param method: 0 = median cut

| 1 = maximum coverage

| 2 = fast octree

| 3 = libimagequant

| :param kmeans: Integer

| :param palette: Quantize to the :py:class:

PIL.ImagingPalette

palette.

| :returns: A new image

|

| resize(self, size, resample=0)

| Returns a resized copy of this image.

|

| :param size: The requested size in pixels, as a 2-tuple:

| (width, height).

| :param resample: An optional resampling filter. This can be

| one of :py:attr:

PIL.Image.NEAREST

, :py:attr:

PIL.Image.BOX

,

| :py:attr:

PIL.Image.BILINEAR

, :py:attr:

PIL.Image.HAMMING

,

| :py:attr:

PIL.Image.BICUBIC

or :py:attr:

PIL.Image.LANCZOS

.

| If omitted, or if the image has mode “1” or “P”, it is

| set :py:attr:

PIL.Image.NEAREST

.

| See: :ref:

concept-filters

.

| :returns: An :py:class:

~PIL.Image.Image

object.

|

| rotate(self, angle, resample=0, expand=0)

| Returns a rotated copy of this image. This method returns a

| copy of this image, rotated the given number of degrees counter

| clockwise around its centre.

|

| :param angle: In degrees counter clockwise.

| :param resample: An optional resampling filter. This can be

| one of :py:attr:

PIL.Image.NEAREST

(use nearest neighbour),

| :py:attr:

PIL.Image.BILINEAR

(linear interpolation in a 2x2

| environment), or :py:attr:

PIL.Image.BICUBIC

| (cubic spline interpolation in a 4x4 environment).

| If omitted, or if the image has mode “1” or “P”, it is

| set :py:attr:

PIL.Image.NEAREST

. See :ref:

concept-filters

.

| :param expand: Optional expansion flag. If true, expands the output

| image to make it large enough to hold the entire rotated image.

| If false or omitted, make the output image the same size as the

| input image.

| :returns: An :py:class:

~PIL.Image.Image

object.

|

| save(self, fp, format=None, **params)

| Saves this image under the given filename. If no format is

| specified, the format to use is determined from the filename

| extension, if possible.

|

| Keyword options can be used to provide additional instructions

| to the writer. If a writer doesn’t recognise an option, it is

| silently ignored. The available options are described in the

| :doc:

image format documentation

| <../handbook/image-file-formats>

for each writer.

|

| You can use a file object instead of a filename. In this case,

| you must always specify the format. The file object must

| implement the

seek

,

tell

, and

write

| methods, and be opened in binary mode.

|

| :param fp: A filename (string), pathlib.Path object or file object.

| :param format: Optional format override. If omitted, the

| format to use is determined from the filename extension.

| If a file object was used instead of a filename, this

| parameter should always be used.

| :param options: Extra parameters to the image writer.

| :returns: None

| :exception KeyError: If the output format could not be determined

| from the file name. Use the format option to solve this.

| :exception IOError: If the file could not be written. The file

| may have been created, and may contain partial data.

|

| seek(self, frame)

| Seeks to the given frame in this sequence file. If you seek

| beyond the end of the sequence, the method raises an

| EOFError exception. When a sequence file is opened, the

| library automatically seeks to frame 0.

|

| Note that in the current version of the library, most sequence

| formats only allows you to seek to the next frame.

|

| See :py:meth:

~PIL.Image.Image.tell

.

|

| :param frame: Frame number, starting at 0.

| :exception EOFError: If the call attempts to seek beyond the end

| of the sequence.

|

| show(self, title=None, command=None)

| Displays this image. This method is mainly intended for

| debugging purposes.

|

| On Unix platforms, this method saves the image to a temporary

| PPM file, and calls either the xv utility or the display

| utility, depending on which one can be found.

|

| On macOS, this method saves the image to a temporary BMP file, and opens

| it with the native Preview application.

|

| On Windows, it saves the image to a temporary BMP file, and uses

| the standard BMP display utility to show it (usually Paint).

|

| :param title: Optional title to use for the image window,

| where possible.

| :param command: command used to show the image

|

| split(self)

| Split this image into individual bands. This method returns a

| tuple of individual image bands from an image. For example,

| splitting an “RGB” image creates three new images each

| containing a copy of one of the original bands (red, green,

| blue).

|

| :returns: A tuple containing bands.

|

| tell(self)

| Returns the current frame number. See :py:meth:

~PIL.Image.Image.seek

.

|

| :returns: Frame number, starting with 0.

|

| thumbnail(self, size, resample=3)

| Make this image into a thumbnail. This method modifies the

| image to contain a thumbnail version of itself, no larger than

| the given size. This method calculates an appropriate thumbnail

| size to preserve the aspect of the image, calls the

| :py:meth:

~PIL.Image.Image.draft

method to configure the file reader

| (where applicable), and finally resizes the image.

|

| Note that this function modifies the :py:class:

~PIL.Image.Image

| object in place. If you need to use the full resolution image as well,

| apply this method to a :py:meth:

~PIL.Image.Image.copy

of the original

| image.

|

| :param size: Requested size.

| :param resample: Optional resampling filter. This can be one

| of :py:attr:

PIL.Image.NEAREST

, :py:attr:

PIL.Image.BILINEAR

,

| :py:attr:

PIL.Image.BICUBIC

, or :py:attr:

PIL.Image.LANCZOS

.

| If omitted, it defaults to :py:attr:

PIL.Image.BICUBIC

.

| (was :py:attr:

PIL.Image.NEAREST

prior to version 2.5.0)

| :returns: None

|

| tobitmap(self, name=’image’)

| Returns the image converted to an X11 bitmap.

|

| .. note:: This method only works for mode “1” images.

|

| :param name: The name prefix to use for the bitmap variables.

| :returns: A string containing an X11 bitmap.

| :raises ValueError: If the mode is not “1”

|

| tobytes(self, encoder_name=’raw’, *args)

| Return image as a bytes object.

|

| .. warning::

|

| This method returns the raw image data from the internal

| storage. For compressed image data (e.g. PNG, JPEG) use

| :meth:

~.save

, with a BytesIO parameter for in-memory

| data.

|

| :param encoder_name: What encoder to use. The default is to

| use the standard “raw” encoder.

| :param args: Extra arguments to the encoder.

| :rtype: A bytes object.

|

| toqimage(self)

| Returns a QImage copy of this image

|

| toqpixmap(self)

| Returns a QPixmap copy of this image

|

| tostring(self, *args, **kw)

|

| transform(self, size, method, data=None, resample=0, fill=1)

| Transforms this image. This method creates a new image with the

| given size, and the same mode as the original, and copies data

| to the new image using the given transform.

|

| :param size: The output size.

| :param method: The transformation method. This is one of

| :py:attr:

PIL.Image.EXTENT

(cut out a rectangular subregion),

| :py:attr:

PIL.Image.AFFINE

(affine transform),

| :py:attr:

PIL.Image.PERSPECTIVE

(perspective transform),

| :py:attr:

PIL.Image.QUAD

(map a quadrilateral to a rectangle), or

| :py:attr:

PIL.Image.MESH

(map a number of source quadrilaterals

| in one operation).

| :param data: Extra data to the transformation method.

| :param resample: Optional resampling filter. It can be one of

| :py:attr:

PIL.Image.NEAREST

(use nearest neighbour),

| :py:attr:

PIL.Image.BILINEAR

(linear interpolation in a 2x2

| environment), or :py:attr:

PIL.Image.BICUBIC

(cubic spline

| interpolation in a 4x4 environment). If omitted, or if the image

| has mode “1” or “P”, it is set to :py:attr:

PIL.Image.NEAREST

.

| :returns: An :py:class:

~PIL.Image.Image

object.

|

| transpose(self, method)

| Transpose image (flip or rotate in 90 degree steps)

|

| :param method: One of :py:attr:

PIL.Image.FLIP_LEFT_RIGHT

,

| :py:attr:

PIL.Image.FLIP_TOP_BOTTOM

, :py:attr:

PIL.Image.ROTATE_90

,

| :py:attr:

PIL.Image.ROTATE_180

, :py:attr:

PIL.Image.ROTATE_270

or

| :py:attr:

PIL.Image.TRANSPOSE

.

| :returns: Returns a flipped or rotated copy of this image.

|

| ———————————————————————-

| Data descriptors inherited from PIL.Image.Image:

|

| array_interface

|

| dict

| dictionary for instance variables (if defined)

|

| weakref

| list of weak references to the object (if defined)

|

| height

|

| width

|

| ———————————————————————-

| Data and other attributes inherited from PIL.Image.Image:

|

| hash = None