Nauč se Python > Kurzy > Datový kurz PyLadies > API > API

Co je API?

Klient a server

API (Application Programming Interface) je dohoda mezi dvěma stranami o tom, jak si mezi sebou budou povídat. Těmto stranám se říká klient a server.

Server je ta strana, která má zajímavé informace nebo něco zajímavého umí a umožňuje ostatním na internetu, aby toho využili. Server je program, který donekonečna běží na nějakém počítači a je připraven všem ostatním na internetu odpovídat na požadavky.

Klient je program, který posílá požadavky na server a z odpovědí se snaží poskládat něco užitečného. Klient je tedy mobilní aplikace s mráčky a sluníčky nebo náš prohlížeč, v němž si můžeme otevřít kurzovní lístek ČNB. Je to ale i Heureka robot, který za Heureku načítá informace o zboží v e-shopech.

Serverové straně se v těchle materiálech nebudeme věnovat. Koho by to zajímalo, nechť se podívá na cojeapi.cz

Základní pojmy

Než se pustíme do tvorby klienta, projdeme si některé základní pojmy kolem API.

Protokol

Celé dorozumívání mezi klientem a serverem se odehrává přes tzv. protokol. To není nic jiného, než smluvený způsob, co bude kdo komu posílat a jakou strukturu to bude mít. Protokolů je v počítačovém světě spousta, ale nás bude zajímat jen HTTP, protože ten využívají webová API a ostatně i web samotný. Není to náhoda, že adresa internetových stránek v prohlížeči zpravidla začíná http:// (nebo https://).

HTTP

Dorozumívání mezi klientem a serverem probíhá formou požadavku (HTTP request), jenž posílá klient na server, a odpovědi (HTTP response), kterou server posílá zpět. Každá z těchto zpráv má své náležitosti.

Požadavek (request)

  • metoda (HTTP method): Například metoda GET má tu vlastnost, že pouze čte a nemůžeme s ní tedy přes API něco změnit - je tzv. bezpečná. Kromě metody GET existují ještě metody POST (vytvořit), PUT (aktualizovat) a DELETE (odstranit), které nepotřebujeme, protože data z API budeme pouze získávat.
  • adresa s parametry (URL s query parameters): Na konci běžné URL adresy otazník a za ním parametry. Pokud je parametrů víc, oddělují se znakem &. Adresa samotná nejčastěji určuje o jaká data půjde (v našem příkladě jsou to filmy) a URL parametry umožňují provést filtraci už na straně serveru a získat tím jen ta data, která nás opravdu zajímají (v našem případě dramata v délce 150 min)
      http://api.example.com/movies/
  http://api.example.com/movies?genre=drama&duration=150
  • hlavičky (headers): Hlavičky jsou vlastně jen další parametry. Liší se v tom, že je neposíláme jako součást adresy a na rozdíl od URL parametrů podléhají nějaké standardizaci a konvencím.
  • tělo (body): Tělo zprávy je krabice, kterou s požadavkem posíláme, a do které můžeme vložit, co chceme. Tedy nejlépe něco, čemu bude API na druhé straně rozumět. Tělo může být prázdné. V těle můžeme poslat obyčejný text, data v nějakém formátu, ale klidně i obrázek. Aby API na druhé straně vědělo, co v krabici je a jak ji má rozbalovat, je potřeba s tělem zpravidla posílat hlavičku Content-Type.

Musíme vyčíst z dokumentace konkrétního API, jak požadavek správně poskládat.

Odpověď (response)

  • status kód (status code): Číselný kód, kterým API dává najevo, jak požadavek zpracovalo. Podle první číslice kódu se kódy dělí na různé kategorie:
      1xx - informativní odpověď (požadavek byl přijat, ale jeho zpracování pokračuje)
  2xx - požadavek byl v pořádku přijat a zpracován
  3xx - přesměrování, klient potřebuje poslat další požadavek jinam, aby se dobral odpovědi
  4xx - chyba na straně klienta (špatně jsme poskládali dotaz)
  5xx - chyba na straně serveru (API nezvládlo odpovědět)
  • hlavičky (headers): Informace o odpovědi jako např. datum zpracování, formát odpovědi...
  • tělo (body): Tělo odpovědi - to, co nás zajímá většinou nejvíc

Formáty

Tělo může být v libovolném formátu. Může to být text, HTML, obrázek, PDF soubor, nebo cokoliv jiného. Hodnotě hlavičky Content-Type se dávají různé názvy: content type, media type, MIME type. Nejčastěji se skládá jen z typu a podtypu, které se oddělí lomítkem. Několik příkladů:

  • text/plain - obyčejný text
  • text/html - HTML
  • text/csv - CSV
  • image/gif - GIF obrázek
  • image/jpeg - JPEG obrázek
  • image/png - PNG obrázek
  • application/json - JSON
  • application/xml nebo text/xml - XML

Formát JSON

JSON vznikl kolem roku 2000 a brzy se uchytil jako stručnější náhrada za XML, především na webu a ve webových API. Dnes je to nejspíš nejoblíbenější formát pro obecná strukturovaná data vůbec. Jeho autorem je Douglas Crockford, jeden z lidí podílejících se na vývoji jazyka JavaScript.

Jeho oblíbenost pramení nejspíš i z jeho jednoduchosti. Ostatně tenhle jupyter notebook je uložen ve formátu JSON. Jeho plná specifikace je popsaná pomocí několika diagramů na stránce json.org.

JSON je datový formát NE datový typ!

Vstupem je libovolná datová struktura:

  • číslo
  • řetězec
  • pravdivostní hodnota
  • pole
  • objekt
  • None

Výstupem je vždy řetězec (string)

title

Jazyk Python (a mnoho dalších) má podporu pro práci s JSON v základní instalaci (vestavěný).

V případě jazyka Python si lze JSON splést především se slovníkem (dictionary). Je ale potřeba si uvědomit, že JSON je text, který může být uložený do souboru nebo odeslaný přes HTTP, ale nelze jej přímo použít při programování. Musíme jej vždy nejdříve zpracovat na slovníky a seznamy.

In [1]:
import json

V následujícím JSONu je pod klíčem "people" seznam slovníků s další strukturou:

In [2]:
people_info = '''
{
    "people": [
        {
            "name": "John Smith",
            "phone": "555-246-999",
            "email": ["johns@gmail.com", "jsmith@gmail.com"],
            "is_employee": false
        },
        {
            "name": "Jane Doe",
            "phone": "665-296-659",
            "email": ["janed@gmail.com", "djane@gmail.com"],
            "is_employee": null
        }
    ]
}
'''

json.loads převede řetězec na objekt

In [3]:
data = json.loads(people_info)
In [4]:
data
Out[4]:
{'people': [{'name': 'John Smith',
   'phone': '555-246-999',
   'email': ['johns@gmail.com', 'jsmith@gmail.com'],
   'is_employee': False},
  {'name': 'Jane Doe',
   'phone': '665-296-659',
   'email': ['janed@gmail.com', 'djane@gmail.com'],
   'is_employee': None}]}
In [5]:
type(data)
Out[5]:
dict
In [6]:
type(data['people'])
Out[6]:
list
In [7]:
type(data['people'][0])
Out[7]:
dict
In [8]:
data['people']
Out[8]:
[{'name': 'John Smith',
  'phone': '555-246-999',
  'email': ['johns@gmail.com', 'jsmith@gmail.com'],
  'is_employee': False},
 {'name': 'Jane Doe',
  'phone': '665-296-659',
  'email': ['janed@gmail.com', 'djane@gmail.com'],
  'is_employee': None}]
In [9]:
data['people'][0]
Out[9]:
{'name': 'John Smith',
 'phone': '555-246-999',
 'email': ['johns@gmail.com', 'jsmith@gmail.com'],
 'is_employee': False}
In [10]:
data['people'][0]['name']
Out[10]:
'John Smith'

Úkol

Stáhněte json z http://pyvec.org/cs/api.json a napište kód, který vypíše jména členů rady (board) české python organizace.

Tip: json jde stáhnout i přímo z notebooku pomocí knihovny requests.

In [ ]:
%pip install requests
In [11]:
import requests
In [ ]:
response = requests.get('http://pyvec.org/cs/api.json')
data = json.loads(response.text)
data

Práce s API klienty

Obecný klient

Mobilní aplikace na počasí je klient, který někdo vytvořil pro jeden konkrétní úkol a pracovat umí jen s jedním konkrétním API. Takový klient je užitečný, pokud chceme akorát vědět, jaké je počasí, ale už méně, pokud si chceme zkoušet práci s více API zároveň. Proto existují obecní klienti.

Prohlížeč jako obecný klient

Pokud z API chceme pouze číst a API nevyžaduje žádné přihlašování, můžeme jej vyzkoušet i v prohlížeči, jako by to byla webová stránka. Pokud na stránkách ČNB navštívíme kurzovní lístek a úplně dole klikneme na Textový formát, uvidíme odpověď z API serveru

https://www.cnb.cz/cs/financni_trhy/devizovy_trh/kurzy_devizoveho_trhu/denni_kurz.txt

Obecný klient v příkazové řádce: curl

Pokud se k API budeme potřebovat přihlásit nebo s ním zkoušet dělat složitější věci než jen čtení, nebude nám prohlížeč stačit.

Proto je dobré se naučit používat program curl. Spouští se v příkazové řádce a je to švýcarský nůž všech, kteří se pohybují kolem webových API.

Příklady s curl

title

Když příkaz zadáme a spustíme, říkáme tím programu curl, že má poslat požadavek na uvedenou adresu a vypsat to, co mu ČNB pošle zpět.

title

Vlastní klient

Obecného klienta musí ovládat člověk (ruční nastavování parametrů, pravidelné spuštění na základě podmínek či času atd.). To je přesně to, co potřebujeme, když si chceme nějaké API vyzkoušet, ale celý smysl API je v tom, aby je programy mohly využívat automaticky. Pokud chceme naprogramovat klienta pro konkrétní úkol, můžeme ve většině jazyků použít buď vestavěnou, nebo doinstalovanou knihovnu. V případě jazyka Python použijeme knihovnu Requests.

Každé slušné API má dokumentaci, kde je popsáno celé fungování API. Tedy všechny možné url (endpointy), metody, parametry, formáty, chybové kódy atd. Dokumentace může mít formu webové stránky jako na příkladu pražských dat nebo dat od britské policie, které za chvíli použijeme. Velmi často používaným způsobem popisu API je také OpenAPI (dříve Swagger). API je pomocí tohoto standardu popsáno v textovém formátu, který jde pak vizualizovat jako na příkladu tohohle smyšleného Zverimexu. Takovýhle standardizovaný popis je i strojově zpracovatelný.

Golemio - pražská veřejná data

Golemio je pražská datová platforma. Dokumentace je k nalezení na https://golemioapi.docs.apiary.io/# Použijeme data o průjezdech cyklistů měřícími zařízeními. Jejich umístění a aktuální počty průjezdů jsou vidět na interaktivní mapě https://unicam.camea.cz/Discoverer/BikeCounter/map.

In [ ]:
%pip install requests
In [13]:
from datetime import datetime, timedelta
import json
import requests

V každém dotazu se musíme autorizovat pomocí API klíče. Ten získáme po bezplatné registraci na https://api.golemio.cz/api-keys/auth/sign-up.

Klíč slouží například k omezení počtu dotazů. Momentálně jde poslat 10000 dotazů za 10 vteřin.

API klíč se vkládá do hlavičky dotazu s názvem x-access-token. Připravíme si tedy hlavičku. Bude se používat pro všechny dotazy na API

Zdroj: https://golemioapi.docs.apiary.io/#introduction/general-info/usage

In [14]:
GOLEMIO_API_KEY = 'zde vložte svůj klíč'
headers = {
  'Content-Type': 'application/json; charset=utf-8',
  'x-access-token': GOLEMIO_API_KEY,
}

Dokumentace k endpointu o průjezdech cyklistů je zde https://golemioapi.docs.apiary.io/#reference/traffic/bicyclecounters/get-all-bicyclecounters.

Kromě specifikace dat jde API i vyzkoušet přímo na webu. Stačí zkopírovat API klíč.

In [16]:
response = requests.get('https://api.golemio.cz/v2/bicyclecounters/', headers=headers)
response
Out[16]:
<Response [200]>
In [17]:
response.raise_for_status()
In [18]:
type(response)
Out[18]:
requests.models.Response
In [ ]:
dir(response)
In [ ]:
response.text
In [ ]:
response.json()
In [ ]:
response.status_code
In [ ]:
data_json = json.loads(response.content)
data_json

Nebo jednodušeji přímo pomocí připravené metody json.

In [ ]:
data_json = response.json()
data_json
In [22]:
type(data_json['features'])
Out[22]:
list
In [23]:
data_json['features'][0]
Out[23]:
{'geometry': {'coordinates': [14.3986383, 50.0718897], 'type': 'Point'},
 'properties': {'directions': [{'id': 'camea-BC_AL-PL',
    'name': 'Plzeňská (z centra)'},
   {'id': 'camea-BC_AL-ST', 'name': 'Štefánikova (centrum)'}],
  'id': 'camea-BC_AL-STPL',
  'name': 'Anděl (Plzeňská)',
  'route': 'A14',
  'updated_at': '2021-06-09T19:00:00.569Z'},
 'type': 'Feature'}
In [24]:
print(data_json['features'][0]['properties']['id'])
print(data_json['features'][0]['properties']['name'])
print(data_json['features'][0]['properties']['directions'][0]['id'])
print(data_json['features'][0]['properties']['directions'][1]['id'])

camea-BC_AL-STPL
Anděl (Plzeňská)
camea-BC_AL-PL
camea-BC_AL-ST
In [ ]:
def get_bicycle_counters() -> dict:
    """ Return all bicycle counters """
    response = requests.get('https://api.golemio.cz/v2/bicyclecounters/', headers=headers)
    
    # this raises exception if response status code is error (starts with 4 or 5)
    response.raise_for_status()
    
    counters = {}
    for counter in response.json()['features']:
        counter_id = counter['properties']['id']
        counter_name = counter['properties']['name']
        direction_ids = [direction['id'] for direction in counter['properties']['directions'] if direction['id']]
        
        # skip empty counters
        if len(direction_ids) == 0:
            continue
        
        counters[counter_id] = {
            'name': counter_name,
            'direction_ids': direction_ids,
        }
    
    return counters

bicycle_counters = get_bicycle_counters()
bicycle_counters
In [26]:
response = requests.get('https://api.golemio.cz/v2/bicyclecounters/detections?id=ecoCounter-103047647&aggregate=true', headers=headers)
response.json()
Out[26]:
[{'id': 'ecoCounter-103047647',
  'value': 333809,
  'value_pedestrians': None,
  'locations_id': 'ecoCounter-100047647',
  'measurement_count': '47490',
  'measured_from': '1970-01-01T00:00:00.000Z',
  'measured_to': '2021-06-09T19:03:31.613Z'}]
In [29]:
def get_bike_count(counter_direction_id: str, time_from: datetime, duration: timedelta = None) -> int:
    """ Return number of bike detections of counter in one direction in specific time frame """
    if duration is None:
        duration = timedelta(days=1)
        
    params = {
        'id': counter_direction_id,
        'from': time_from.isoformat(),
        'to': (time_from + duration).isoformat(),
        'aggregate': 'true',
    }
    
    response = requests.get('https://api.golemio.cz/v2/bicyclecounters/detections', params=params, headers=headers)
    response.raise_for_status()
    
    # no measurments
    if len(response.json()) == 0:
        return 0
    
    return response.json()[0]['value']


# example usage
get_bike_count('camea-BC_AL-ST', datetime(2020, 12, 1), timedelta(days=1))
Out[29]:
97
In [31]:
def get_all_directions_counts(station_id: str, *args, counters: dict=None, **kwargs) -> tuple:
    """ Return number of bike detections in all directions in a dict (direction_id: count).
        Parameters are similar to get_bike_count function (see the usage on last line).
    """
    if counters is None:
        counters = get_bicycle_counters()
    
    counts = {}
    for direction_id in counters[station_id]['direction_ids']:
        counts[direction_id] = get_bike_count(direction_id, *args, **kwargs)
        
        
    return counts

get_all_directions_counts('camea-BC_VK-MOKO', datetime(2021, 6, 2, 11), timedelta(hours=1))
Out[31]:
{'camea-BC_VK-KO': 67, 'camea-BC_VK-MO': 50}

Úkoly

  • Kolik cyklistů projelo včera v čase 6.00 - 11.00 v Modřanech?
  • Které místo bylo včera nejfrekventovanější? A které druhé?

Další úkoly jsou bez řešení. Můžete si je vyzkoušet po hodině. Stahování dat může trvat docela dlouho.

In [33]:
# Řešení počtu cyklistů v Modřanech v jednotlivých směrech

for id, counter in get_bicycle_counters().items():
    if counter['name'] != 'Modřany':
        continue
    
    for direction_id in counter['direction_ids']:
        count = get_bike_count(direction_id, datetime(2021, 6, 2, 11), timedelta(hours=5))
        print(id, direction_id, count)

camea-BC_VK-MOKO camea-BC_VK-KO 687
camea-BC_VK-MOKO camea-BC_VK-MO 367
In [ ]:
# Získání počtu cyklistů pro všechny stanice v daném dni
# stažení chvíli trvá, průběžné výsledky se vypisují

day_counts = []
for station_id in bicycle_counters:
    print(station_id, end='')
    counts = get_all_directions_counts(
        station_id, datetime(2021, 6, 1), duration=timedelta(days=1), counters=bicycle_counters
    )
    
    print(station_id, bicycle_counters[station_id]['name'], counts, sum(counts.values()))

    day_counts.append((station_id, bicycle_counters[station_id]['name'], sum(counts.values())))
    
day_counts
In [36]:
# první dvě nejfrekventovanější místa - řešení v pythonu
sorted_counts = sorted(
    day_counts,               # tenhle seznam chceme seřadit
    key=lambda row: row[2],   # pro řazení použít třetí položku z tuple
    reverse=True              # od nejvyššího (default je od nejnižšího)
)             

sorted_counts[:2]             # první dva záznamy
Out[36]:
[('camea-BC_PT-ZOVO', 'Povltavská', 3357),
 ('camea-BC_PN-VYBR2', 'Podolské nábřeží - vozovka', 3331)]
In [37]:
import pandas as pd
In [38]:
# první dvě nejfrekventovanější místa - řešení v pandas
day_counts_df = pd.DataFrame(day_counts, columns=['station_id', 'name', 'day_count'])
day_counts_df = day_counts_df.set_index('station_id')
day_counts_df.sort_values('day_count', ascending=False)[:2]
Out[38]:
name day_count
station_id
camea-BC_PT-ZOVO Povltavská 3357
camea-BC_PN-VYBR2 Podolské nábřeží - vozovka 3331

Zločinnost v UK

Příklad dalšího veřejného API

Vyzkoušíme si dotazy na API s daty zločinnosti v UK, která jsou dostupná na měsiční bázi dle přibližné lokace (viz https://data.police.uk/docs/method/stops-at-location/)

In [39]:
api_url = "https://data.police.uk/api/stops-street"

Nastavení parametrů volání API dle dokumentace https://data.police.uk/docs/method/stops-at-location/ Jako lokaci jsem vybral nechvalně proslulý obvod Hackney v Londýně :)

In [40]:
params = {
    "lat" : "51.5487158",
    "lng" : "-0.0613842",
    "date" : "2018-06"
}

Pomocí funkce get pošleme požadavek na URL adresu API. URL adresa doplněná o parametry vypadá takto: https://data.police.uk/api/stops-street?lat=51.5487158&lng=-0.0613842&date=2018-06 a je možné ji vyzkoušet i v prohlížeči.

V proměnné response máme uložený objekt, který obsahuje odpověď od API.

In [41]:
response = requests.get(api_url, params=params)

Pokud je status kód jiný, než 200 (success), vyhodí skript chybu a chybový status code

In [42]:
if response.status_code != 200:
    print('Failed to get data:', response.status_code)
else:
    print('First 100 characters of data are')
    print(response.text[:100])

First 100 characters of data are
[{"age_range":"18-24","outcome":"Community resolution","involved_person":true,"self_defined_ethnicit

Hlavička s doplňujícími informacemi o opdovědi

In [43]:
response.headers
Out[43]:
{'Date': 'Wed, 09 Jun 2021 19:22:00 GMT', 'Content-Type': 'application/json', 'Content-Length': '5687', 'Connection': 'keep-alive', 'Vary': 'Accept-Encoding', 'Access-Control-Allow-Origin': '*', 'Content-Encoding': 'gzip', 'Strict-Transport-Security': 'max-age=31536000;', 'X-XSS-Protection': '1; mode=block', 'X-Content-Type-Options': 'nosniff', 'X-Frame-Options': 'DENY', 'Content-Security-Policy': "default-src 'self' 'unsafe-inline' ; script-src 'self' data: www.google-analytics.com ajax.googleapis.com 'unsafe-inline';", 'Referer-Policy': 'strict-origin-when-cross-origin'}
In [44]:
response.headers['content-type']
Out[44]:
'application/json'

Obsah odpovědi je řetězec bytů

In [45]:
response.content[:200]
Out[45]:
b'[{"age_range":"18-24","outcome":"Community resolution","involved_person":true,"self_defined_ethnicity":"Black\\/African\\/Caribbean\\/Black British - Any other Black\\/African\\/Caribbean background","gend'

Vypadá jako seznam (list) nebo slovník (dictionary), ale nechová se tak:

In [46]:
response[0]["age_range"]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-46-ec7ac01c28cf> in <module>
----> 1 response[0]["age_range"]

TypeError: 'Response' object is not subscriptable

Převedeme řetězec bytů metodou .json() z knihovny requests

In [47]:
data = response.json()

Ověříme datový typ

In [48]:
type(data)
Out[48]:
list

Nyní můžeme přistupovat k "data" jako ke klasickému seznamu (list)

In [49]:
data[0]["age_range"]
Out[49]:
'18-24'

Převední seznamu(list) na řetězec s parametry pro zobrazení struktury v čitelné podobě

In [50]:
datas = json.dumps(data, sort_keys=True, indent=4)
In [51]:
print(datas[:1600])

[
    {
        "age_range": "18-24",
        "datetime": "2018-06-01T09:45:00+00:00",
        "gender": "Male",
        "involved_person": true,
        "legislation": "Misuse of Drugs Act 1971 (section 23)",
        "location": {
            "latitude": "51.551330",
            "longitude": "-0.068037",
            "street": {
                "id": 968551,
                "name": "On or near Downs Park Road"
            }
        },
        "object_of_search": "Controlled drugs",
        "officer_defined_ethnicity": "Black",
        "operation": false,
        "operation_name": null,
        "outcome": "Community resolution",
        "outcome_linked_to_object_of_search": null,
        "outcome_object": {
            "id": "bu-community-resolution",
            "name": "Community resolution"
        },
        "removal_of_more_than_outer_clothing": null,
        "self_defined_ethnicity": "Black/African/Caribbean/Black British - Any other Black/African/Caribbean background",
        "type": "Person search"
    },
    {
        "age_range": "18-24",
        "datetime": "2018-06-02T02:37:00+00:00",
        "gender": "Male",
        "involved_person": true,
        "legislation": "Misuse of Drugs Act 1971 (section 23)",
        "location": {
            "latitude": "51.549626",
            "longitude": "-0.054738",
            "street": {
                "id": 968830,
                "name": "On or near Dalston Lane"
            }
        },
        "object_of_search": "Controlled drugs",
        "officer_defined_ethnicity": "Black",
        "operation": false,
        "operat

Cyklus, kterým přistupujeme k věkovému rozpětí lidí lustrovaných policií

In [52]:
age_range = [i["age_range"] for i in data]
In [53]:
print(age_range)

['18-24', '18-24', 'over 34', '18-24', '10-17', '10-17', 'over 34', '25-34', 'over 34', '25-34', None, '25-34', '18-24', '10-17', None, '18-24', None, '18-24', '10-17', 'over 34', '18-24', '18-24', '18-24', '18-24', '18-24', '18-24', '18-24', '18-24', '18-24', '25-34', '18-24', '18-24', '18-24', 'over 34', '10-17', '10-17', '25-34', '18-24', '18-24', '25-34', '25-34', '25-34', 'over 34', 'over 34', '18-24', '18-24', '18-24', '18-24', '18-24', '25-34', '25-34', 'over 34', '25-34', 'over 34', '18-24', '25-34', '25-34', 'over 34', '18-24', None, '18-24', '18-24', None, '18-24', '18-24', '25-34', '10-17', '25-34', '18-24', '25-34', '18-24', None, '18-24', '25-34', '25-34', '25-34', '18-24', '25-34', '25-34', '18-24', '18-24', '10-17', 'over 34', 'over 34', '18-24', '18-24', '25-34', '10-17', '18-24', 'over 34', '10-17', '25-34', 'over 34', '18-24', '25-34', 'over 34', '25-34', '18-24', '18-24', '18-24', '18-24', '10-17', '10-17', '18-24', '25-34', '18-24', '25-34', '18-24', '18-24', '10-17', '25-34', '18-24', 'over 34', '10-17', '18-24', 'over 34', '18-24', '10-17', '10-17', 'over 34', '25-34', '10-17', '10-17', '25-34', '10-17', '10-17', '10-17', '10-17', '18-24', '10-17', '10-17', None, 'over 34', '10-17', '10-17', '25-34', '10-17', '18-24', '10-17', None, '10-17', '10-17', '25-34', '18-24', '18-24', '25-34', '10-17', '10-17', '25-34', '10-17', None, '25-34', '25-34', '18-24', '10-17', '25-34', '18-24', '10-17', '10-17', '25-34', None, '18-24', '25-34', '25-34', '10-17', '10-17', '18-24', 'over 34', '18-24', '18-24', '10-17', '10-17', '25-34', 'over 34', 'over 34', '18-24', '18-24', '25-34', '10-17']

Cyklus, kterým přistupujeme k id ulice, kde došlo lustraci podezřelé(ho)

In [54]:
street_id = [i["location"]["street"]["id"] for i in data]
In [55]:
print(street_id)

[968551, 968830, 968830, 968740, 964026, 964026, 968844, 968662, 968662, 968662, 971832, 971832, 968828, 968828, 968805, 968828, 968805, 968805, 968805, 968584, 964086, 968632, 968632, 964132, 968632, 968632, 968584, 968584, 968872, 971832, 968717, 968866, 971656, 964226, 968662, 968662, 968703, 968668, 968668, 968703, 964013, 968505, 968830, 968500, 968662, 968830, 968830, 968662, 968662, 968705, 964150, 968663, 968663, 968830, 968467, 968662, 968663, 968830, 964370, 964370, 968500, 964287, 964329, 971656, 971656, 968830, 968829, 968830, 968829, 968608, 968703, 968703, 968469, 968662, 968754, 968662, 968872, 968748, 968872, 968691, 968641, 968641, 964023, 964322, 968872, 968872, 968872, 968662, 964219, 964092, 964219, 968854, 968662, 968662, 968662, 968786, 968584, 968662, 964266, 964316, 964266, 968637, 968637, 968804, 968804, 968804, 971758, 968804, 968662, 964297, 968830, 968770, 968500, 968662, 968804, 968500, 964324, 964266, 964225, 968816, 968500, 964266, 968641, 968575, 968828, 968828, 968828, 968489, 968815, 968564, 964266, 968871, 968687, 964091, 968815, 971713, 971801, 968662, 964208, 968614, 968802, 968839, 964085, 968630, 968642, 964098, 964312, 964312, 968872, 964248, 971656, 968872, 968872, 968804, 968647, 968884, 968844, 968872, 968763, 968830, 968804, 968854, 968609, 968662, 968830, 968489, 968603, 971832, 968641, 968830, 968647, 968489, 968496, 968606, 968626, 968606, 968369, 968660, 968815]
In [56]:
import pandas as pd

Spojíme seznamy do dataframe

In [57]:
df_from_lists = pd.DataFrame(list(zip(age_range, street_id)), 
                columns = ['age_range', 'street_id'])
In [58]:
df_from_lists.head()
Out[58]:
age_range street_id
0 18-24 968551
1 18-24 968830
2 over 34 968830
3 18-24 968740
4 10-17 964026

Jakou věkovou skupinu lustrovala policie nejčastěji?

In [ ]:
In [59]:
%matplotlib inline

---------------------------------------------------------------------------
ModuleNotFoundError                       Traceback (most recent call last)
<ipython-input-59-9e3324102725> in <module>
----> 1 get_ipython().run_line_magic('matplotlib', 'inline')

~/Dokumenty/pydata/venv/lib/python3.7/site-packages/IPython/core/interactiveshell.py in run_line_magic(self, magic_name, line, _stack_depth)
   2346                 kwargs['local_ns'] = self.get_local_scope(stack_depth)
   2347             with self.builtin_trap:
-> 2348                 result = fn(*args, **kwargs)
   2349             return result
   2350 

~/Dokumenty/pydata/venv/lib/python3.7/site-packages/decorator.py in fun(*args, **kw)
    230             if not kwsyntax:
    231                 args, kw = fix(args, kw, sig)
--> 232             return caller(func, *(extras + args), **kw)
    233     fun.__name__ = func.__name__
    234     fun.__doc__ = func.__doc__

~/Dokumenty/pydata/venv/lib/python3.7/site-packages/IPython/core/magic.py in <lambda>(f, *a, **k)
    185     # but it's overkill for just that one bit of state.
    186     def magic_deco(arg):
--> 187         call = lambda f, *a, **k: f(*a, **k)
    188 
    189         if callable(arg):

~/Dokumenty/pydata/venv/lib/python3.7/site-packages/IPython/core/magics/pylab.py in matplotlib(self, line)
     97             print("Available matplotlib backends: %s" % backends_list)
     98         else:
---> 99             gui, backend = self.shell.enable_matplotlib(args.gui.lower() if isinstance(args.gui, str) else args.gui)
    100             self._show_matplotlib_backend(args.gui, backend)
    101 

~/Dokumenty/pydata/venv/lib/python3.7/site-packages/ipykernel/zmqshell.py in enable_matplotlib(self, gui)
    599 
    600     def enable_matplotlib(self, gui=None):
--> 601         gui, backend = super(ZMQInteractiveShell, self).enable_matplotlib(gui)
    602 
    603         try:

~/Dokumenty/pydata/venv/lib/python3.7/site-packages/IPython/core/interactiveshell.py in enable_matplotlib(self, gui)
   3515         """
   3516         from IPython.core import pylabtools as pt
-> 3517         from matplotlib_inline.backend_inline import configure_inline_support
   3518         gui, backend = pt.find_gui_and_backend(gui, self.pylab_gui_select)
   3519 

~/Dokumenty/pydata/venv/lib/python3.7/site-packages/matplotlib_inline/backend_inline.py in <module>
      4 # Distributed under the terms of the BSD 3-Clause License.
      5 
----> 6 import matplotlib
      7 from matplotlib.backends.backend_agg import (  # noqa
      8     new_figure_manager,

ModuleNotFoundError: No module named 'matplotlib'
In [ ]:
df_from_lists["age_range"].value_counts().plot.bar();

Json_normalize

aneb jak jednoduše převést JSON na DataFrame

In [ ]:
data
In [ ]:
from pandas import json_normalize
In [ ]:
norm_data = json_normalize(data)
In [ ]:
norm_data.head()
In [ ]:
norm_data["gender"].value_counts()
In [ ]:
norm_data["gender"].value_counts().plot.bar();
In [ ]:
norm_data["age_range"].value_counts().plot.bar();

Tvoříme vlastního klienta

V následujícím bloku si vytvoříme klienta, který nám stáhne data za dva měsíce (místo jednoho) a uloží je do seznamu seznamů (list of lists). Případné chyby spojení s API ošetříme výjimkami (exceptions) - více viz dokumentace requests

In [ ]:
def get_uk_crime_data(latitude, longitude, dates_list):
    """
    Function loops through a list of dates 
    
    Three arguments latitude, longitude and a list of dates
    
    Returns a dataframe with crime data for each day
    """
    appended_data = []
    
    for i in dates_list:
        api_url = "https://data.police.uk/api/stops-street"
        params = {
            "lat" : latitude,
            "lng" : longitude,
            "date" : i
        }
        response = requests.get(api_url, params=params)
        data_foo = response.json()
            
        data = pd.json_normalize(data_foo)
        # store DataFrame in list
        appended_data.append(data)
       
    return pd.concat(appended_data)

Zavolání funkce get_uk_crime_data s parametry zeměpisné šíře a délky přiřazené proměnné df_uk_crime_data

In [ ]:
dates_list = ["2018-06","2018-07"]
lat = "51.5487158"
lng = "-0.0613842"

df_uk_crime_data = get_uk_crime_data(lat, lng, dates_list)
In [ ]:
df_uk_crime_data.head()

Přistupování k tweetům přes Twitter API pomocí knihovny Tweepy

Příkaz na instalaci knihovny tweepy uvnitř notebooku. Stačí odkomentovat a spustit.

In [ ]:
%pip install tweepy
In [ ]:
import tweepy

Pro získání dat z Twitteru musí náš klient projít OAuth autorizací.

Jak funguje OAuth autorizace na Twitteru?

  1. vývojář aplikace se zaregistruje u poskytovatele API
  2. zaregistruje aplikaci, získá consumer_key, consumer_secret, access_token a access_secret na https://developer.twitter.com/en/apps
  3. aplikace volá API a prokazuje se consumer_key, consumer_secret, access_token a access_secret
In [ ]:
consumer_key = ""
consumer_secret = ""
access_token = ""
access_secret = ""

Další krok je vytvoření instance OAuthHandleru, do kterého vložíme náš consumer token a consumer secret

In [ ]:
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_secret)

Ověření funkčnosti autentifikace

In [ ]:
api = tweepy.API(auth)

try:
    api.verify_credentials()
    print("Authentication OK")
except Exception:
    print("Error during authentication")

V API dokumentaci k Tweepy http://docs.tweepy.org/en/v3.5.0/api.html najdeme metodu která např. vypíše ID přátel, resp. sledujících účtu

In [ ]:
api.friends_ids('@kdnuggets')

Nebo vypíše ID, které účet sleduje

In [ ]:
api.followers_ids('@kdnuggets')

Metoda, která vrátí posledních 20 tweetů podle ID uživatele

In [ ]:
twitter_user = api.user_timeline('@kdnuggets')
In [ ]:
twitter_user
In [ ]:
kdnuggets_tweets = [i.text for i in twitter_user]
kdnuggets_tweets
In [ ]:
dir(twitter_user[0])
In [ ]:
twitter_user[0].retweet_count
In [ ]:
def get_tweets(consumer_key, consumer_secret, access_token, access_secret, twitter_account):
    """
    Function gets the last 20 tweets and adds those not in the list
    
    Five arguments consumer_key, consumer_secret, access_token, access_secret, and twitter_account name
    
    Returns a dataframe with tweets for given account
    """
    
    auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
    auth.set_access_token(access_token, access_secret)
    api = tweepy.API(auth)

    try:
        api.verify_credentials()
        print("Authentication OK")
        twitter_user = api.user_timeline(twitter_account)
        
        tweets_list = [i.text for i in twitter_user]
                      
    except Exception:
        print("Error dubing authentication")
    
    return pd.DataFrame(tweets_list, columns = [twitter_account])
In [ ]:
%pip install pandas
In [ ]:
import pandas as pd
In [ ]:
get_tweets(consumer_key, consumer_secret, access_token, access_secret, '@honzajavorek')

Tweety můžeme vyhledávat i podle hashtagu!

In [ ]:
for tweet in api.search('#masks4all'):
    print(tweet.user.screen_name, tweet.text)
    print('---')

Takhle ale dostaneme jenom 20 posledních tweetů. Pokud by nám to nestačilo, tak podle dokumentace k metodě search můžeme nastavit return per page rpp=30, to jde ale nastavit maximálně na hodnotu 100. Pokud bychom chtěli víc, potřebujeme procházet výsledky po stránkách. Tedy nastavovat parametr page=2 a postupně procházet cyklem. Stránky se tu číslují od jedné.

Toto je stránka lekce z kurzu, který probíhá nebo proběhl naživo s instruktorem.
↑ Lekce: API
Závěr lekce →

Uprav tuto stránku na GitHubu

Pro PyDataCZ napsal Dan Cupak, 2020.

Licence: Creative Commons Attribution-ShareAlike 4.0 International