Raspberry Pi PCF8591 ADC Max Sampling Rate and High Frequency Signal Detection

I am trying to detect different frequency signals using a Raspberry Pi and an ADC converter (PCF8591). My initial guess was the highest frequency I could detect would be limited by the speed of the I2C bus (which is about 400000 bauds). But when I run the setup, I could only get sampling speeds of around 10000 samples/sec. This value lies very close to the time taken to run an empty for loop in python (which is about 10^(-5) seconds which is equivalent to 10^(5) samples/sec).

I wanted to reach higher frequency domain (around 10 MHz) and using a better ADC won't be of much help since the limitation is set by the program itself. I wanted to know if my conclusion is correct or not. I have a feeling I am very wrong and doing something stupid. Any guidance will be much appreciated. Below is the python code I am using for signal detection.
#!/usr/bin/python
# -*- coding:utf-8 -*-
import smbus
import time
import matplotlib.pyplot as plt

start = time.time()

address = 0x48
A0 = 0x40
A1 = 0x41
A2 = 0x42
A3 = 0x43
bus = smbus.SMBus(1)
bus.write_byte_data(address,0,0b00010000)#control byte to tell ADC to act as a differential input

voltage_value = [ ]
time_value = [ ]

try:
    while True:
        bus.write_byte(address,A0)
        value = bus.read_byte(address)
        voltage_value.append(value)
        time_value.append(time.time()-start)
        #print("AOUT:%1.3f " %(value*3.3/255))
        #print(value)
        #time.sleep(0.1)
except KeyboardInterrupt:
    voltage_value = [x*3.3/255 for x in voltage_value]
    plt.plot(time_value,voltage_value)
    plt.ylabel('Voltage')
    plt.xlabel('Time')
    plt.show()

    with open('output.txt', 'w') as f:
        for v,t in zip(voltage_value,time_value):
            f.write(str(v)+' '+str(t)+'n')

10,000 samples sounds about right for an I2C bus. Just considering the I2C bus at 400,000 bits per second, in order to read out a single sample, you'll 8 bits to address the device, 8 bits to set the address you want to read, 8 bits to address the read and assuming a 12 bit ADC value, 16 bits to read the value. Adding all that up, you get 40 bits to transfer a single sample; 400,000 bps / 40 bits = 10,000 samples / second.
You could try to use an internal ADC to reach MHz rates. I'm not sure what the Raspberry Pi provides in that respect. There isn't any peripheral bus like UART, I2C or SPI that will give you enough deterministic bandwidth to sample at 10 MHz that immediately comes to mind. It's hard to determine possible solutions though without more information about the application. 

Depending no what exactly you are doing, you could use an external microcontroller to sample and provide any filtering/analysis and then communicate the results at a slower sample rate to the Raspberry PI.

My aim is to make a digital lock-in amplifier using Raspberry Pi. It is working only till frequencies up to 2KHz as of now. I wanted it to reach higher frequency ranges.

I'm no expert on any of this but if you are only interested in the frequency, why use an ADC?  Just square up the input waveform using a fast comparator and just count transitions on an input.  You could also use a divider IC to bring the frequency down to a manageable value, and just multiply by that ratio in software.

For starters, the ADC is no use, as you have pointed out, its sampling rate is dictated by the I2C clock rate, so you need a better ADC. There are high speed ADCs about that will do what you want.Are you ultimately wanting to present the data in near real time and scroll it, or just display a frame after a fixed number of samples are acquired, and if so, what sort of screen update rate do you need.What sort of ADC resolution and dynamic range do you need, eight bits is fine for a small display, but are you processing the data further.As has been pointed out, and I have used the technique with a micropython board in a data logger to get fast deterministic  sampling rates, you have to offload the acquisition side of things from the host processor handling the data presentation. Depending on the speed needed, another fast,  low pin count processor or an FPGA can do that. A command from the host processor starts the sampling, and the ADC processor(or FPGA)handles all of the sampling and buffering process . Things get a bit more complicated if you have to do things like double buffering. Once you have the required data, it is then uploaded to the host processor.
You may have to use C++ for the graphics processing if you need fast display updates.Just a few thoughts,cheers,Richard

I wonder if a Software-Defined Radio dongle, like an RTL-SDR might do the trick.  The input range is from 500Khz to 1.75Ghz and there is software available to run it from the Raspberry Pi.
-Rick