To make requests to Google APIs the work flow is in essence the following:

1. Go to developer console, log in if you haven't.
2. Create a Cloud Platform project.
3. Enable for your project, the APIs you are interested in using with you projects' apps (for example: Google Drive API).
4. Create and download OAuth 2.0 Client IDs credentials that will allow your app to gain authorization for using your enabled APIs.
5. Head over to OAuth consent screen, click on and add your scope using the button. (scope: https://www.googleapis.com/auth/drive.readonly for you). Choose Internal/External according to your needs, and for now ignore the warnings if any.
6. To get the valid token for making API request the app will go through the OAuth flow to receive the authorization token. (Since it needs consent)
7. During the OAuth flow the user will be redirected to your the OAuth consent screen, where it will be asked to approve or deny access to your app's requested scopes.
8. If consent is given, your app will receive an authorization token.
9. Pass the token in your request to your authorized API endpoints.^[2]
10. Build a Drive Service to make API requests (You will need the valid token)^[1]

NOTE:

The available methods for the Files resource for Drive API v3 are here.

When using the Python Google APIs Client, then you can use export_media() or get_media() as per Google APIs Client for Python documentation

IMPORTANT:

Also, check that the scope you are using, actually allows you to do what you want (Downloading Files from user's Drive) and set it accordingly. ATM you have an incorrect scope for your goal. See OAuth 2.0 API Scopes

Sample Code References:

1. Building a Drive Service:

import google_auth_oauthlib.flow
from google.auth.transport.requests import Request
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build
 
 
class Auth:
 
    def __init__(self, client_secret_filename, scopes):
        self.client_secret = client_secret_filename
        self.scopes = scopes
        self.flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(self.client_secret, self.scopes)
        self.flow.redirect_uri = 'http://localhost:8080/'
        self.creds = None
 
    def get_credentials(self):
        flow = InstalledAppFlow.from_client_secrets_file(self.client_secret, self.scopes)
        self.creds = flow.run_local_server(port=8080)
        return self.creds

 
# The scope you app will use. 
# (NEEDS to be among the enabled in your OAuth consent screen)
SCOPES = "https://www.googleapis.com/auth/drive.readonly"
CLIENT_SECRET_FILE = "credentials.json"
 
credentials = Auth(client_secret_filename=CLIENT_SECRET_FILE, scopes=SCOPES).get_credentials()
 
drive_service = build('drive', 'v3', credentials=credentials)

2. Making the request to export or get a file

request = drive_service.files().export(fileId=file_id, mimeType='application/pdf')

fh = io.BytesIO()
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
    status, done = downloader.next_chunk()
    print("Download %d%%" % int(status.progress() * 100))

# The file has been downloaded into RAM, now save it in a file
fh.seek(0)
with open('your_filename.pdf', 'wb') as f:
    shutil.copyfileobj(fh, f, length=131072)

just write the content variable to a file instead of returning the content

fo = open("foo.jpg", "wb")
fo.write(content)
fo.close()

If by "drive's url" you mean the shareable link of a file on Google Drive, then the following might help:

import sys
import requests


def download_file_from_google_drive(file_id, destination):
    URL = "https://docs.google.com/uc?export=download&confirm=1"

    session = requests.Session()

    response = session.get(URL, params={"id": file_id}, stream=True)
    token = get_confirm_token(response)

    if token:
        params = {"id": file_id, "confirm": token}
        response = session.get(URL, params=params, stream=True)

    save_response_content(response, destination)


def get_confirm_token(response):
    for key, value in response.cookies.items():
        if key.startswith("download_warning"):
            return value

    return None


def save_response_content(response, destination):
    CHUNK_SIZE = 32768

    with open(destination, "wb") as f:
        for chunk in response.iter_content(CHUNK_SIZE):
            if chunk:  # filter out keep-alive new chunks
                f.write(chunk)


def main():
    if len(sys.argv) >= 3:
        file_id = sys.argv[1]
        destination = sys.argv[2]
    else:
        file_id = "TAKE_ID_FROM_SHAREABLE_LINK"
        destination = "DESTINATION_FILE_ON_YOUR_DISK"
    print(f"dowload {file_id} to {destination}")
    download_file_from_google_drive(file_id, destination)


if __name__ == "__main__":
    main()

The snipped does not use pydrive, nor the Google Drive SDK, though. It uses the requests module (which is, somehow, an alternative to urllib2).

When downloading large files from Google Drive, a single GET request is not sufficient. A second one is needed - see wget/curl large file from google drive.

I don't know the documentation page you're mentioning but, in order to download a file, get its metadata and make an authenticated request to its downloadUrl.

f = service.files().get(fileId=file_id).execute()
resp, content = service._http.request(f.get('downloadUrl'))

The lines below and starting with 'file_id=....' are indented with 2 spaces from the left. However the code above it are indented with 4 spaces. If these lines of code are to be within the 'main' function, they need to be indented like the rest of the code... 4 spaces at a time.

This is a common error when copying and pasting code. If you plan to further extend the code, either modify the copied code to match or change your style to suit. Note development environments like PyCharm and VSCode have settings to configure the default indentation.

Example in Google doc uses

fh = io.BytesIO()

so it reads data into memory and it doesn't save on disk.

You have to save it using (for example)

my_file = open(filename, 'wb')
my_file.write(fh)
my_file.close()

EDIT: information for others - as @michelle.70 found - we can use

fh = io.FileIO(filename, 'wb') 

instead of fh = io.BytesIO() and it will save it in file.

It should also work if you use normal open()

fh = open(filename, 'wb')

Don't forget to close fh (in both methods).