from PIL import Image
im = 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