I'll have to agree with some of the other that I don't see the need for using a class in this case, although you get a little credit for using the naming scheme for public and privat methods.

But what I would focus on is your _is_number_divisible_by_five_and_three() & co methods. You say that you're happy with them as they do just one thing. In my book they are too localised and specific. They are not very reusable, and you would be better served with one general method:

def is_divisible(number, modulo):
    """Return if number % modulo is equal to 0."""

    return number % modulo == 0

This would allow you to simplify your logic in the badly name parse_number() to use is_divisible(number, 3) and so on. Now you have a function with might be useful elsewhere, even though still pretty simple.

As a general principle if you see repeating blocks of code you can:

• Consider if the blocks can be collated into one single function, like for is_divisible()
• Consider if the blocks can be converted into a loop of some sorts, like in parse_numbers() where you do the same test (with a different number) and returning a text in all cases

In addition your code calculates the modulo one time too much as you could already know the answer for number % 15. A good way to handle this, minimizing calculations, is to build a list of all fizz buzz words, and then for the final output check if you have values in the list and join them together. If no values in list, return the string version of the number.

Code refactored

Here is an alternate version combining these suggestions, and an extension allowing for additional fizz buzz words:

from collections import namedtuple

def is_divisible(number, modulo):
    """Return if number % modulo is equal to 0."""

    return number % modulo == 0


FizzBuzz = namedtuple('FizzBuzz', 'number, name')

fizz_buzz_words = [
    FizzBuzz( 3, 'Fizz'),
    FizzBuzz( 4, 'Buzz'),
    FizzBuzz( 7, 'Bang'),
    FizzBuzz(11, 'Boom'),
  ]

def to_fizz_buzz_string(n):
    """Returns an extended FizzBuzz string representation of a number."""
    fizz_buzzes = [fb.name for fb in fizz_buzz_words if is_divisible(n, fb.number)]

    return ''.join(fizz_buzzes) if fizz_buzzes else str(n)


for a in range(124, 134):
   print to_fizz_buzz_string(a)

print ', '.join(to_fizz_buzz_string(n) for n in range(923, 935))

At end is two different ways to call the newly created to_fizz_buzz_string() conversion method.

A Class is for persistent state, here some top level functions would work as well with less code bloat.

When you write:

number_list = [] 
for number in range(1, end_number+1):
     number_list.append(self.parse_number(number))
return number_list

You are just mapping parse_number over a range, so just use map (or a generator expression).

You've got a solid start here, but consider a real world problem (and the common follow up question to Fizz Buzz):

The customer now wants your program to also print "Bang" when the number is a multiple of 7.

So, with your current process, you'd need a couple more if statements (for 7, 21 and 35). Not too hard to do, and you can just copy the code you already have for the most part, so this is doable.

But then a few years go by and the company gets bigger. Now, when the number is a multiple of 11, you need to print "Boom".

So are you going to write out a chain of 24 if statements? What if you mess up a number somewhere? Or put the if conditions in the wrong order, like having the check for 15 before the check for 165? You have an unmanageable mess.

The correct solution is to use a list, pairing each number requirement to its word, and build the "FizzBuzzBangBoom" string as you iterate over the list. The method to add a "word" to the string operates the same no matter what the number input is - it's just a modulo function - so you can cut down on a lot of repetition.

As a challenge, try to repeat your project with less repetition (the DRY principle) and SPECIFICALLY do not have the numbers 3, 5, 7 or 11, or any multiples of them, appear in your code more than once.

How about a bit of dependency injection?

# -*- coding: utf-8 -*-
"""A generic configurable FizzBuzz."""

from functools import partial


def byn(number, div, out):
    assert isinstance(number, int)
    assert isinstance(div, int)
    if number % div == 0:
        return out
    return ''


def to_str(number):
    return str(number)


class FizzBuzz(object):

    _actions = (
        partial(byn, div=3, out='fizz'),
        partial(byn, div=5, out='buzz'),
    )

    _default_action = partial(to_str)

    def __init__(self, actions=None, default_action=None):
        if actions:
            self._actions = actions
        if default_action:
            self._default_action = default_action

    def response(self, number):
        rstr = ''
        for action in self._actions:
            rstr += action(number)
        if not rstr:
            rstr = self._default_action(number)
        return rstr

Full code at https://github.com/cleder/FizzBuzz