Python入门：PIL(pillow)之im对象(Image.open('file.jpeg'))

from PIL import Imageim = Image.open('file.jpeg')

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) |   |  __getattr__(self, name) |   |  __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. |       |      This is a lazy operation.  Changes to the source image may or |      may not be reflected in the cropped image.  To break the |      connection, call the :py:meth:`~PIL.Image.Image.load` method on |      the cropped copy. |       |      :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 |      :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` (use nearest neighbour), |         :py:attr:`PIL.Image.BILINEAR` (linear interpolation), |         :py:attr:`PIL.Image.BICUBIC` (cubic spline interpolation), or |         :py:attr:`PIL.Image.LANCZOS` (a high-quality downsampling filter). |         If omitted, or if the image has mode "1" or "P", it is |         set :py:attr:`PIL.Image.NEAREST`. |      :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`. |      :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 the **xv** utility. |       |      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: |   |  __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