Python is an official language at Google. Alongside two other prominent languages Java and C++. Google even supports the development of Python programming language and sponsors various Pyhon conferences like PyCon. Until 2012, the designer and creator of Python, Guido van Rossum was employed by Google when left to work for DropBox.

Well, coming to the question, Python is used at Google for its countless internal systems as well as:

1. Most of the core search algorithms at Google are written in Python and C++.
2. Various build systems, log analysis, code review tools etc are written in Python by Googlers.
3. Lots of Open Source libraries .
4. Various Data and API libraries like Google Data Python Client Library, Google APIs Client Library for Python and Google AdWords API Python Client Library.
5. YouTube : Previously it was written in PHP but eventually it was replaced by Python and the site uses Python heavily for various purposes like view video etc.
6. One of the main website for hosting for Google developers code.google.com as well.
7. And currently, most of the Machine Learning, AI as well as robotics projects at Google are implemented using Python and lots of C++.

You can use a Google API by setting up a Google Cloud project and enabling the desired API. Then, use the provided credentials to make requests from your app.

Steps to Use a Google API:

• Create a Project: Go to Google Cloud Console and create a new project.
• Enable the API: Search for and enable the API you want to use (e.g., Maps, Drive).
• Get Credentials: Generate an API key, OAuth client ID, or service account.
• Install SDK or Use REST: Use Google’s client libraries or make HTTP requests.
• Build Your App: Start making API calls from your code.

As per my knowledge Google has discontinued this service. But you don’t have to worry there are many alternative to Google News API.

5 Best Google News Feed API Alternative:

1. NewsDataio
2. NewsAPI
3. Mediastack
4. Guardian API
5. Bing News API

Choose wisely from above list. I have used all of them and finds NewsDataio is the best alternative to Google News API.

You can also use NewsDataio’s Google News API in Python.

Do follow these simple steps:

1. Sign-up or create an account.
2. Obtain the API key
3. Understand the API documentation.

For more detailed description you can visit to their News API Documentation page where they have provided client library for PHP and Python users.

It is difficult to answer this question without a clearer description of what kind of control or interaction you would want from Python. Certainly a Python program can generate a page with a Google map (using the Flask web application framework, for example). The actual real-time interaction would still come through JavaScript events and calls, but JavaScript can make Ajax calls to an application in Python, so you could still get Python involved if you wanted to do some behind-the-scenes computation in Python. I don't think you could completely avoid the JavaScript layer, though. Google's contractual provisions also restrict what you can do ... you must be interacting with the user through a Google map display, not doing some offline action like producing a printed map.

If the contractual restriction gets in your way, you could use the very nice Leaflet.js API with OpenStreetMap data served by MapBox. It presents a similar interface to the user, is wonderfully documented for the developer (but all in JavaScript; the link to Python would be up to you), and for at least some parts of the world the quality of the user-provided map data is excellent. Personally, if I wanted to have an interactive map with some Python code behind the curtain, I'd use the Flask web app framework with Leafleet and MapBox data. In fact I plan to do just that sometime in the next month or so, to replace a prototype that uses Python running in CGI-bin scripts.

1. Most of the core search algorithms at Google are written in Python and C++.
2. Various build systems, log analysis, code review tools etc are written in Python by Googlers.
3. Lots of Open Source libraries .
4. Various Data and API libraries like Google Data Python Client Library, Google APIs Client Library for Python and Google AdWords API Python Client Library.
5. YouTube : Previously it was written in PHP but eventually it was replaced by Python and the site uses Python heavily for various purposes like view video etc.
6. One of the main website for hosting for Google developers code.google.com as well.
7. And currently, most of the Machine Learning, AI as well as robotics projects at Google are implemented using Python and lots of C++.

Unfortunately, Google News has no official API now as confirmed by this community answer.

But if you want to extract news articles from Google News, you can use 3rd party APIs. But they can be costly. Fortunately, I’ve just published a Quora post that explains all possible ways of scraping Google news along with their benefits, drawbacks, and legality.

Below is how I achieved the the similar kind while I started to learn python. It's much easy to achieve your purpose. I Leart doing this kind of task in one day.

Note: Steps mentioned below are just to give you an idea about achieving the purpose, they are not actual.

1. Red input from user using input()
1. show = input(“Tv show name”)
2. Urllib & Requests for working with URL, something like below
1. workUrl = ‘google.com/’ + str(show)
2. sourcecode = requests.get(workurl)
3. sourcecodetext = sourcecode.text
3. Use Beautiful Soup 4, where it's general purpose is web scrape.
1. Go through bs4 tutorials and find to achieve your purpose, its simple.
4. Selenium to browser navigation.
5. Save the code tills step 4 as filename.py file
6. Run from cmd

So required libraries are Requests, Urllib, beautifulsoup4 (reads source code and fetchs what you want) and selenium.

I assume you know that API stands for Application Programming Interface. So in order to use an API from any language the first thing you need is documentation of the API. Part of that documentation should reveal whether they support access directly from Python. Many programs do, but certainly not all; you can't rely on that. Let's assume the API is callable from only from C, from a specific C compiler. In that case chances are someone may have written a C program that has Python callable functions that use the C only API and return values through to the Python caller. If not, you could do that! There are software tools which are extremely helpful in writing C functions that are meant to be called from Python. One I know of is open source.

What is an API?

An API, or Application Programming Interface, is a server that you can use to retrieve and send data to using code. APIs are most commonly used to retrieve data, and that will be the focus of this beginner tutorial.

When we want to receive data from an API, we need to make a request. Requests are used all over the web. For instance, when you visited this blog post, your web browser made a request to the Dataquest web server, which responded with the content of this web page.

API requests work in exactly the same way – you make a request to an API server for data, and it responds to your request.

Making API Requests in Python

In order to work with APIs in Python, we need tools that will make those requests. In Python, the most common library for making requests and working with APIs is the requests library. The requests library isn’t part of the standard Python library, so you’ll need to install it to get started.

If you use pip to manage your Python packages, you can install requests using the following command:

pip install requests 

If you use conda, the command you’ll need is:

conda install requests 

Once you’ve installed the library, you’ll need to import it. Let’s start with that important step:

import requests 

Now that we’ve installed and imported the requests library, let’s start using it.

Making Our First API Request

There are many different types of requests. The most commonly used one, a GET request, is used to retrieve data. Because we’ll just be working with retrieving data, our focus will be on making ‘get’ requests.

When we make a request, the response from the API comes with a response code which tells us whether our request was successful. Response codes are important because they immediately tell us if something went wrong.

To make a ‘GET’ request, we’ll use the requests.get() function, which requires one argument — the URL we want to make the request to. We’ll start by making a request to an API endpoint that doesn’t exist, so we can see what that response code looks like.

response = requests.get("http://api.open-notify.org/this-api-doesnt-exist") 

The get() function returns a response object. We can use the response.status_code attribute to receive the status code for our request:

print(response.status_code) 
404 

The ‘404’ status code might be familiar to you — it’s the status code that a server returns if it can’t find the file we requested. In this case, we asked for this-api-doesnt-exist which (surprise, surprise) didn’t exist!

Let’s learn a little more about common status codes.

API Status Codes

Status codes are returned with every request that is made to a web server. Status codes indicate information about what happened with a request. Here are some codes that are relevant to GET requests:

• 200: Everything went okay, and the result has been returned (if any).
• 301: The server is redirecting you to a different endpoint. This can happen when a company switches domain names, or an endpoint name is changed.
• 400: The server thinks you made a bad request. This can happen when you don’t send along the right data, among other things.
• 401: The server thinks you’re not authenticated. Many APIs require login ccredentials, so this happens when you don’t send the right credentials to access an API.
• 403: The resource you’re trying to access is forbidden: you don’t have the right permissions to see it.
• 404: The resource you tried to access wasn’t found on the server.
• 503: The server is not ready to handle the request.

You might notice that all of the status codes that begin with a ‘4’ indicate some sort of error. The first number of status codes indicate their categorization. This is useful — you can know that if your status code starts with a ‘2’ it was successful and if it starts with a ‘4’ or ‘5’ there was an error. If you’re interested you can read more about status codes here.

API Documentation

In order to ensure we make a successful request, when we work with APIs it’s important to consult the documentation. Documentation can seem scary at first, but as you use documentation more and more you’ll find it gets easier.

We’ll be working with the Open Notify API, which gives access to data about the international space station. It’s a great API for learning because it has a very simple design, and doesn’t require authentication. We’ll teach you how to use an API that requires authentication in a later post.

Often there will be multiple APIs available on a particular server. Each of these APIs are commonly called endpoints. The first endpoint we’ll use is http://api.open-notify.org/astros.json, which returns data about astronauts currently in space.

If you click the link above to look at the documentation for this endpoint, you’ll see that it says This API takes no inputs. This makes it a simple API for us to get started with. We’ll start by making a GET request to the endpoint using the requests library:

response = requests.get("http://api.open-notify.org/astros.json") 
print(response.status_code) 
200 

We received a ‘200’ code which tells us our request was successful. The documentation tells us that the API response we’ll get is in JSON format. In the next section we’ll learn about JSON, but first let’s use the response.json() method to see the data we received back from the API:

print(response.json()) 
{'message': 'success', 'people': [{'name': 'Alexey Ovchinin', 'craft': 'ISS'}, {'name': 'Nick Hague', 'craft': 'ISS'}, {'name': 'Christina Koch', 'craft': 'ISS'}, {'name': 'Alexander Skvortsov', 'craft': 'ISS'}, {'name': 'Luca Parmitano', 'craft': 'ISS'}, {'name': 'Andrew Morgan', 'craft': 'ISS'}], 'number': 6} 

Working with JSON Data in Python

JSON (JavaScript Object Notation) is the language of APIs. JSON is a way to encode data structures that ensures that they are easily readable by machines. JSON is the primary format in which data is passed back and forth to APIs, and most API servers will send their responses in JSON format.

You might have noticed that the JSON output we received from the API looked like it contained Python dictionaries, lists, strings and integers. You can think of JSON as being a combination of these objects represented as strings. Let’s look at a simple example:

Python has great JSON support with the json package. The json package is part of the standard library, so we don’t have to install anything to use it. We can both convert lists and dictionaries to JSON, and convert strings to lists and dictionaries. In the case of our ISS Pass data, it is a dictionary encoded to a string in JSON format.

The json library has two main functions:

• json.dumps() — Takes in a Python object, and converts (dumps) it to a string.
• json.loads() — Takes a JSON string, and converts (loads) it to a Python object.

The dumps() function is particularly useful as we can use it to print a formatted string which makes it easier to understand the JSON output, like in the diagram we saw above:

import json 
 
def jprint(obj): 
    # create a formatted string of the Python JSON object 
    text = json.dumps(obj, sort_keys=True, indent=4) 
    print(text) 
 
jprint(response.json()) 
{ 
    "message": "success", 
    "number": 6, 
    "people": [ 
        { 
            "craft": "ISS", 
            "name": "Alexey Ovchinin" 
        }, 
        { 
            "craft": "ISS", 
            "name": "Nick Hague" 
        }, 
        { 
            "craft": "ISS", 
            "name": "Christina Koch" 
        }, 
        { 
            "craft": "ISS", 
            "name": "Alexander Skvortsov" 
        }, 
        { 
            "craft": "ISS", 
            "name": "Luca Parmitano" 
        }, 
        { 
            "craft": "ISS", 
            "name": "Andrew Morgan" 
        } 
    ] 
} 

Immediately we can understand the structure of the data more easily – we can see that their are six people currently in space, with their names existing as dictionaries inside a list.

If we compare this to the documentation for the endpoint we’ll see that this matches the specified output for the endpoint.

Using an API with Query Parameters

The http://api.open-notify.org/astros.json endpoint we used earlier does not take any parameters. We just send a GET request and the API sends back data about the number of people currently in space.

It’s very common, however, to have an API endpoint that requires us to specify parameters. An example of this the http://api.open-notify.org/iss-pass.json endpoint. This endpoint tells us the next times that the international space station will pass over a given location on the earth.

If we look at the documentation, it specifies required lat (latitude) and long (longitude) parameters.

We can do this by adding an optional keyword argument, params, to our request. We can make a dictionary with these parameters, and then pass them into the requests.get function. Here’s what our dictionary would look like, using coordinates for New York City:

parameters = { 
    "lat": 40.71, 
    "lon": -74 
} 

We can also do the same thing directly by adding the parameters directly to the URL. like this: http://api.open-notify.org/iss-pass.json?lat=40.71&lon;=-74.

It’s almost always preferable to setup the parameters as a dictionary, because requests takes care of some things that come up, like properly formatting the query parameters, and we don’t need to worry about inserting the values into the URL string.

Let’s make a request using these coordinates and see what response we get.

response = requests.get("http://api.open-notify.org/iss-pass.json", params=parameters) 
 
jprint(response.json()) 
{ 
    "message": "success", 
    "request": { 
        "altitude": 100, 
        "datetime": 1568062811, 
        "latitude": 40.71, 
        "longitude": -74.0, 
        "passes": 5 
    }, 
    "response": [ 
        { 
            "duration": 395, 
            "risetime": 1568082479 
        }, 
        { 
            "duration": 640, 
            "risetime": 1568088118 
        }, 
        { 
            "duration": 614, 
            "risetime": 1568093944 
        }, 
        { 
            "duration": 555, 
            "risetime": 1568099831 
        }, 
        { 
            "duration": 595, 
            "risetime": 1568105674 
        } 
    ] 
} 

Understanding the Pass Times

The JSON response matches what the documentation specified:

• A dictionary with three keys
• The third key, response, contains a list of pass times
• Each pass time is a dictionary with risetime (pass start time) and duration keys.

Let’s extract the pass times from our JSON object:

pass_times = response.json()['response'] 
jprint(pass_times) 
[ 
    { 
        "duration": 395, 
        "risetime": 1568082479 
    }, 
    { 
        "duration": 640, 
        "risetime": 1568088118 
    }, 
    { 
        "duration": 614, 
        "risetime": 1568093944 
    }, 
    { 
        "duration": 555, 
        "risetime": 1568099831 
    }, 
    { 
        "duration": 595, 
        "risetime": 1568105674 
    } 
] 

Next we’ll use a loop to extract just the five risetime values:

risetimes = [] 
 
for d in pass_times: 
    time = d['risetime'] 
    risetimes.append(time) 
 
print(risetimes) 
[1568082479, 1568088118, 1568093944, 1568099831, 1568105674] 

These times are difficult to understand – they are in a format known as timestamp or epoch. Essentially the time is measured in the number of seconds since January 1st 1970. We can use the Python datetime.fromtimestamp() method to convert these into easier to understand times:

from datetime import datetime 
 
times = [] 
 
for rt in risetimes: 
    time = datetime.fromtimestamp(rt) 
    times.append(time) 
    print(time) 
2019-09-09 21:27:59 
2019-09-09 23:01:58 
2019-09-10 00:39:04 
2019-09-10 02:17:11 
2019-09-10 03:54:34 

It looks like the ISS passes over New York City often – the next five times happen within a seven hour period!

Python API Tutorial: Next Steps

In this tutorial, we learned:

• What an API is
• Types of requests and response codes
• How to make a get request
• How to make a request with parameters
• How to display and extract JSON data from an API

These fundamental steps will help you to start working with APIs. Remember that key to each time we used the API was to carefully read the API documentation and use that to understand what request to make and what parameters to provide.

Now you’ve completed our Python API tutorial, you might like to:

• Complete our interactive Dataquest APIs and scraping course, which you can start for free.
• Try working with some data from this list of Free Public APIs — we recommend selecting an API that doesn’t require authentication as a good first step.
• Try our Intermediate API tutorial, which covers API authentication, pagination, and rate limiting

Here is the closest thing I've found (and have been using):
google-ngram-downloader 4.0.0

It lets you iterate over the dataset without downloading it to your computer. You can search by n (the n-gram length) and the first letter of the n-gram, then you need to iterate sequentially until finding the n-gram you need. It's quite slow, but if you only need a few queries and can't download the entire dataset, it can be useful.

For example, if you want to count all the occurrences of a certain word:

from google_ngram_downloader import readline_google_store 
 
count = 0 
fname, url, records = next(readline_google_store(ngram_len=1, indices=word[0])) 
 
try: 
	record = next(records) 
 
	while record.ngram != word: 
		record = next(records) 
 
	while record.ngram == word: 
		count = count + record.match_count 
		record = next(records) 
		 
except StopIteration: 
	pass 

Google's APIs, also known as Application Programming interfaces, are software packages that allow easy communication with Google applications and their corresponding integration with other services.

The basic purpose of Google APIs is to allow a programmer to create programs and applications that interface with Google's web services and databases. An example of such a service is Google's Search, Gmail, or Google Maps.

This article will provide you with an idea of how to create your own Google APIs. As we go through the process of designing our own API, we have to take note of a few things so that the whole process goes smoothly and our application works as expected by Google. First of all, we have to choose a unique name that will represent our service or programmatically.

Next, we have to decide on the type of data we want our application to return from our API. We can choose from the list of available data types that Google provides, but the list is not that extensive.

One example that comes to mind is a list of saved searches, but we should be careful in using such information because once our user starts using the service, any information that was previously stored in his cache will be lost. This is why it is important that we choose a field name that will be easily remembered by our client application.

There are at least 3 main usages of Python in Google:

YouTube is written in Python - not necessarily a good thing; most people who joined YouTube later complained about it; there are plans to move off Python, but it’s not the highest priority.

Most test automation and some site reliability scripts are written in Python. This is leveraging Python’s power as a scripting language.Lots of Machine Learning code is written in Python.

Python is one of the most important languages in ML / AI http://domain.So the total number of people using Python as main language in Google is probably in thousands, and the total number of people who need to touch Python occasionally in Google is likely in tens of thousands.

First go to Google Cloud Platoform and create your project there.

Create Service Account

• Open Service Account Page and Create Services account, write down the name, description and choose unique key
• On the Grant users access to this service account screen, scroll down to the Create key section. Click Create key.
• In the side panel that appears, select the format for your key: JSON is recommended.
• Click Create. Your new public/private key pair is generated and downloaded to your machine.

Now go to website ( my preference is wordpress)

Go to plugin and add new

Search Instant Indexing and install first plugin of Rank Math (Instant Index)

Go to Dashboard and import the JSON file.

Now Configuration is completed.

Go URL Submission and set 100 plus URL’s daily and thery are index in few hours.

You send a specially-encoded url (a ‘request”)(usually a “key” has to be included) to a server, which in turn, if the connection to that server is successful, sends you back certain data that you requested via that specially encoded url.

You can then include that data in the application of your choice.

You do that using the Python requests library

For example:

import requests 
 
"""In this example we're getting weather-related data sent to us by openweathermap.org""" 
 
"""It has to be in the 'City Name, US' format for the request to work.""" 
 
city = "San Francisco, US" 
 
api_key = 'Insert the key you get from the website here' 
 
"""Here we're going to add the "specially-encoded" part via a parameters variable we called 'params'.  The url without the encoding is shown below in the variable we called url""" 
 
url = "http://api.openweathermap.org/data/2.5/weather?" 
 
params = {'appid': api_key, 'q': city, 'state code': 'CA', 'country code': 'US', 'units': 'imperial'} 
 
# With the statement below you are making the actual request. 
 
response = requests.get(url, params=params) 
 
"""With the statement below, your response from the server will be in "JavaScript Object Notation" or 'JSON' format, which looks a lot like a Python Dictionary, with key:value pairs.""" 
 
weather = response.json() 
print(weather) 
 
"""With the url that is printed out below, you will see what your url looks like with the 'special encoding' added.""" 
 
print(response.url) 
 
I hope that helps! 

YouTube's current version of their API works using gdata and so you need to get the gdata Python module which you can do by just doing easy_install gdata. You also need to register for an API key here: http://code.google.com/apis/youtube/dashboard/

The only good getting started guide I could find online was:
http://code.google.com/apis/youtube/1.0/developers_guide_python.html#GettingStarted

Your first code probably should look something like this (pieced together from the link above):

import gdata.youtube 
import gdata.youtube.service 
yt_service = gdata.youtube.service.YouTubeService() 
 
# The YouTube API does not currently support HTTPS/SSL access. yt_service.ssl = False  
yt_service.developer_key = 'ABCxyz123...' 
yt_service.client_id = 'My-Client_id'  

It seems that you can just pick whatever you want for the client id since its just for debugging and identifying for your own purposes.

When working with APIs in Python, several libraries can help with making HTTP requests, handling responses, and managing API interactions. Here’s an overview of some of the most commonly used libraries:

• requests: Simple and popular for synchronous requests.
• httpx: Supports both synchronous and asynchronous requests.
• urllib: Standard library for URL handling.
• aiohttp: For asynchronous requests, useful for high-performance needs.
• tornado: Asynchronous networking and web framework.
• flask and django: For building APIs and web applications.

Each of these libraries serves different purposes and use cases, so the choice depends on your specific requirements and whether you need synchronous or asynchronous operations.

If you don’t have the capacity or time to download portions of the dataset, as suggested in the answer by Vered Shwartz, you can use a web service called PhraseFinder.

To access its public API with Python you need to write code like this:

import urllib 
import requests 
 
encoded_query = urllib.parse.quote('how ?') 
params = {'corpus': 'eng-us', 'query': encoded_query, 'topk': 3, 'format': 'tsv'} 
params = '&'.join('{}={}'.format(name, value) for name, value in params.items()) 
 
response = requests.get('https://api.phrasefinder.io/search?' + params) 
 
print(response.text) 
 
# OUTPUT 
# how_0 to_1     26629791   2574117   1505   2009   1108101562963   0.501017 
# how_0 the_1    14673567   2441347   1500   2009   1108101563731   0.276071 
# how_0 much_1   11848090   2211477   1500   2009   1108101564162   0.222912