Calculating pixel in array

If self._array_ is an array of integers, each representing one byte of raster image data from the original image, then you can extract the bit you want using ordinary bit-manipulation techniques. Here's a detailed explanation (as requested in comments):

1. We need the width of each row in bytes. This is the width in pixels divided by 8, except that the PBM format pads each row with up to 7 dummy pixels to make each row an exact number of bytes. So we need to divide the width by 8 and round up, which can be done using integer arithmetic like this:

   row_width = (width + 7) // 8
   

2. Then we need to find the byte containing the pixel we want. PBM raster data is laid out in row-major order, so the pixel at (x, y) is in this byte:

   pixel_byte = self._array_[y * row_width + x // 8]
   

3. You can extract bit number b (numbering from the right, with least significant bit numbered 0) from the integer i using the operation (i >> b) & 1 (right-shift by b bits and mask off the least significant bit). But PBM lays out its pixels in big-endian order, with the first pixel being in the most significant bit in the byte. So the bit we want is bit number 7 - x % 8:

   (pixel_byte >> (7 - x % 8)) & 1
   

That should solve your immediate problem. But it looks to me as though your code is very complex for what you are trying to do. Some comments:

1. It's pointless calling isinstance and raising a TypeError yourself, because this will happen anyway when you try to do integer operations on the arguments.

2. x > (self.width-1) would be better written as x >= self.width.

3. Python's slice notation allows any negative integer, not just -1. For example:

   >>> range(10)[-7:-4]
   [3, 4, 5]
   

4. You compute a number p but you don't use it.

5. You import the function pprint and then don't call it.

I would write something like this:

import re

class Pbm(object):
    """
    Load a Binary Portable Bitmap (PBM) files and provide access to
    its pixels.  See <http://netpbm.sourceforge.net/doc/pbm.html>
    """
    _pbm_re = re.compile(r'''
       (P4)                     # 1. Magic number
       (?:\s+|\#.*\n)*          # Whitespace or comments
       ([0-9]+)                 # 2. Width of image in pixels
       (?:\s+|\#.*\n)*          # Whitespace or comments
       ([0-9]+)                 # 3. Height of image in pixels
       (?:\#.*\n)*              # Possible comments
       \s                       # A single whitespace character
       ([\000-\377]*)           # 4. Raster image data
    ''', re.X)

    def __init__(self, f):
        m = self._pbm_re.match(f.read())
        if not m:
            raise IOError("Can't parse PBM file.")
        self.width = int(m.group(2))             # Width in pixels
        self.height = int(m.group(3))            # Height in pixels
        self.row = (self.width + 7) // 8         # Width in bytes
        self.raster = m.group(4)
        if len(self.raster) != self.height * self.row:
            raise IOError("Size of raster is {} but width x height = {}."
                          .format(len(self.raster), self.height * self.row))

    def getpixel(self, x, y):
        # Negative coordinates are treated as offsets from the end,
        # like Python's slice indexes.
        if x < 0: x += self.width
        if y < 0: y += self.height
        if x < 0 or x >= self.width or y < 0 or y >= self.height:
            raise ValueError("Coords ({},{}) are out of range (0,0)-({},{})."
                             .format(x, y, self.width - 1, self.height - 1))
        return (ord(self.raster[y * self.row + x // 8]) >> (7 - x % 8)) & 1