def igre_in_zanri_s_strani(potrditev_iskanja_podatkov,
mapa_podatkov,
do,
od=0,
interval_obvestila=250):
'''Iz prenešenih strani izlušči podatke o igrah in žanrih in jih shrani v CSV datoteke.'''
if potrditev_iskanja_podatkov:
igre = []
zanri = []
for i in range(od, do):
if i > 0 and i % interval_obvestila == 0:
print(f"Obdelanij je bilo {i} strani.")
try:
jedro = jedro_s_strani(
orodja.odpri_html(mapa_podatkov, f"{i}.html"))
igre.append(igra_iz_jedra(jedro))
zanri += zanri_iz_jedra(jedro)
except Exception:
print(f"Napaka pri iskanju podatkov v {i}.html")
orodja.zapisi_csv(igre, [
"id", "naslov", "platforma", "studio", "mesec", "leto",
"metascore", "glasovi metascore", "userscore", "glasovi userscore",
"oznaka", "stevilo igralcev", "opis"
], csv_datoteka_igre)
orodja.zapisi_csv(zanri, ["id", "zanr"], csv_datoteka_zanri)
print("Podatki so bili uspešno pridobljeni!")
def main():
if orodja.ne_obstaja(poizvedba.path_json):
poizvedba.zapisi_json(poizvedba.path_json, poizvedba.dat_rq)
obdelaj_json()
podatki = orodja.nalozi_json(novi_json)
poklici = [{"ID": podatek["ID"], "Poklic": poklic} for podatek in podatki for poklic in podatek.pop("Poklici")]
orodja.zapisi_csv(podatki_csv, podatki)
orodja.zapisi_csv(poklici_csv, poklici)
def write(rows, *, main_filename, producer_filename, licensor_filename,
studio_filename, genre_filename):
main_headers = [
'title', 'series_type', 'episodes', 'status', 'premiered', 'source',
'duration', 'rating', 'score', 'votes', 'popularity'
]
main_rows = []
producer_rows = []
licensor_rows = []
studio_rows = []
genre_rows = []
for row in rows:
new_row = {}
for key, value in row.items():
if key in main_headers:
new_row[key] = value
elif key == 'producers':
for producer in value:
producer_rows.append({
'title': row['title'],
'producer': producer
})
elif key == 'licensors':
for licensor in value:
licensor_rows.append({
'title': row['title'],
'licensor': licensor
})
elif key == 'studios':
for studio in value:
studio_rows.append({
'title': row['title'],
'studio': studio
})
elif key == 'genres':
for genre in value:
genre_rows.append({'title': row['title'], 'genre': genre})
main_rows.append(new_row)
orodja.zapisi_csv(main_rows, main_headers,
os.path.join(data_dir, main_filename))
orodja.zapisi_csv(producer_rows, ['title', 'producer'],
os.path.join(data_dir, producer_filename))
orodja.zapisi_csv(licensor_rows, ['title', 'licensor'],
os.path.join(data_dir, licensor_filename))
orodja.zapisi_csv(studio_rows, ['title', 'studio'],
os.path.join(data_dir, studio_filename))
orodja.zapisi_csv(genre_rows, ['title', 'genre'],
os.path.join(data_dir, genre_filename))
def ustvari_csv(vhodna, izhodna):
'''iz json dodateke s seznamom slovarjev podjetij pretvori v csv datoteko'''
podjetja = nalozi_podjetja(orodja.nalozi_json(vhodna))
podjetja = [podjetje.csv_oblika() for podjetje in podjetja]
imena_polj = [
'ime', 'ulica', 'mesto', 'posta', 'regija', 'koordinate', 'center',
'dolzina', 'trajanje', 'pot'
]
orodja.zapisi_csv(podjetja, imena_polj, izhodna)
def popravi_zapisi(seznam):
for nepremicnina in seznam:
nepremicnina['leto'] = int(nepremicnina['leto'])
nepremicnina['velikost'] = float(nepremicnina['velikost'].replace(
'.', '').replace(',', '.'))
nepremicnina['cena'] = int(nepremicnina['cena'])
if nepremicnina['zemljisce'] is not None:
nepremicnina['zemljisce'] = float(
nepremicnina['zemljisce'].replace('.', '').replace(',', '.'))
imena_polj = [
'ime', 'posred', 'vrsta', 'tip', 'leto', 'zemljisce', 'velikost',
'cena', 'agencija', 'regija'
]
orodja.zapisi_csv(seznam, imena_polj, f'podatki/nepremicnine.csv')
orodja.zapisi_json(seznam, f'podatki/nepremicnine.json')
def main(redownload=True, reparse=True):
"""Funkcija izvede celoten del pridobivanja podatkov:
1. Oglase prenese iz bolhe
2. Lokalno html datoteko pretvori v lepšo predstavitev podatkov
3. Podatke shrani v csv datoteko
"""
# Sledeča koda potegne podatke s strani
for i in range(100):
viski_frontpage_url = 'http://whiskyadvocate.com/ratings-reviews/?search=&submit=+&brand_id=0&rating=0&price=0&category=0&styles_id=0&issue_id={}'.format(
103 - i)
print(viski_frontpage_url)
frontpage_filename = 'index{}.html'.format(i)
save_frontpage(viski_frontpage_url, viski_directory,
frontpage_filename)
niz = ""
for stevec in range(100):
ime_dat = "index{}.html".format(stevec)
podatki = read_file_to_string("viski_out", ime_dat)
niz += podatki
save_string_to_file(niz, "viski_out_full", "index_full.html")
stevec = 0
vsebina = read_file_to_string(viski_directory, frontpage_filename)
for blok in vzorec_bloka.findall(vsebina):
viski = vzorec_viskija2.search(blok).groupdict()
stevec += 1
print(stevec)
#
# Naslednji sklop naredi csv file
viskiji = []
for blok in blok_iz_dat("viski_out_full", "index_full.html"):
viskiji.append(blok)
viskiji.sort(key=lambda viski: viski['ocena'])
orodja.zapisi_csv(
viskiji,
[
'ocena', 'ime', 'alkohol', 'kategorija', 'cena', 'opis',
'ocenjevalec', 'cas_ocene'
],
csv_filename,
)
def ustvari_csv():
orodja.zapisi_csv(
vsi_seti, imena_polj,
"/Users/thrawn/Documents/git/Lego-sets/obdelani-podatki/bricksets-database-1999-2019.csv"
)
# testi:
# g = seti_na_spl_strani("/Users/thrawn/Documents/git/Lego-sets/html_na_roke/2019 | Brickset: LEGO set guide and database page-1.html")
# print(next(g))
# y = [x['eu_cas_izida'] for x in g]
# print(y)
# orodja.shrani_spletno_stran('https://brickset.com/sets/year-2019/page-32', "/Users/thrawn/Documents/git/Lego-sets/testni.html", vsili_prenos=True)
#--------------------------pozeni--------------------------
# nalozi_strani()
# zdruzi_database()
# ustvari_json()
# ustvari_csv()
#----------------------------------------------------------
for tekma in tekme:
for uporabnik in uporabniki:
nap = napoved()
if nap:
try:
rezultat = (int(tekma["rezultat"][0]),
int(tekma["rezultat"][-1]))
tocke = tockuj(rezultat, nap)
napovedi.append({
"uporabnik": uporabnik["id"],
"tekma": tekma["stevilka"],
"rez_dom": nap[0],
"rez_gos": nap[1],
"tocke": tocke[0],
"gol_razlika": tocke[1]
})
except:
napovedi.append({
"uporabnik": uporabnik["id"],
"tekma": tekma["stevilka"],
"rez_dom": nap[0],
"rez_gos": nap[1],
"tocke": None,
"gol_razlika": None
})
orodja.zapisi_csv(
napovedi,
["uporabnik", "tekma", "rez_dom", "rez_gos", "tocke", "gol_razlika"],
"obdelani-podatki/napovedi.csv")
anime['dolzina'] = None
else:
if anime['dolzina'][-1] == 'm':
anime['dolzina'] = float(anime['dolzina'].replace(' m', ''))
elif anime['dolzina'][-1] == 's':
anime['dolzina'] = round(
float(anime['dolzina'].replace(' s', '')) / 60, 2)
anime['najljubsi'] = najdi_najljubse(ime_datoteke)
anime['naslov'] = najdi_naslov(ime_datoteke).replace(''',
"'").replace(
'"', '"')
animeji.append(anime)
orodja.zapisi_csv(animeji, [
'id', 'naslov', 'sezona', 'zacetek', 'konec', 'vir', 'epizode', 'dolzina',
'stevilo_clenov', 'najljubsi', 'ocena', 'opis', 'oznaka'
], 'obdelani-podatki/animeji.csv')
orodja.zapisi_csv(vsi_zanri, ['anime', 'zanr'], 'obdelani-podatki/zanri.csv')
orodja.zapisi_csv(vsi_studiji, ['id_studija', 'studio'],
'obdelani-podatki/studiji.csv')
orodja.zapisi_csv(studiji_po_animejih, ['anime', 'studio'],
'obdelani-podatki/studiji_po_animejih.csv')
orodja.zapisi_csv(osebe, ['id', 'ime'], 'obdelani-podatki/osebe.csv')
orodja.zapisi_csv(vloge, ['anime', 'oseba', 'vloga'],
'obdelani-podatki/vloge.csv')
ime_datoteke = f"rabljeni-avtomobili-stran-{stran}.html"
vsebina = orodja.vsebina_datoteke(ime_datoteke)
for oglas in vzorec_oglasa.finditer(vsebina):
urejeni_podatki = izloci_podatke_oglasa(oglas.groupdict())
oglasi.append(urejeni_podatki)
print(f"končana je stran {stran}")
oglasi.sort(key=lambda oglas: oglas["ime_avtomobila"])
return oglasi
urejeni_oglasi = zapisi_oglase()
orodja.zapisi_json(urejeni_oglasi, "obdelani-podatki/oglasi.json")
orodja.zapisi_csv(
urejeni_oglasi,
[
"ime_avtomobila",
"znamka",
"leto_prve_registracije",
"prevozeni_kilometri",
"vrsta_motorja",
"vrsta_menjalnika",
"velikost_motorja",
"moc_motorja",
"cena",
],
"obdelani-podatki/oglasi.csv",
)
orod.shrani_spletno_stran(url1, ime_datoteke2)
nova_vsebina = orod.vsebina_datoteke(ime_datoteke2)
i += 1
yield izloci_podatke_vina(nova_vsebina)
def izloci_gnezdene_podatke(vina):
vonji, okusi = [], []
for vino in vina:
for vonj in vino['vonji']:
vonji.append({'vino': vino['id'], 'vonj': vonj})
for okus in vino['okusi']:
okusi.append({'vino': vino['id'], 'okus': okus})
del vino['vonji']
del vino['okusi']
return vonji, okusi
vina = []
for stran in range(1, 78):
for vino in vina_na_strani(stran):
vina.append(vino)
vina.sort(key=lambda vino: vino['id'])
orod.zapisi_json(vina, 'obdelani-podatki/vina.json')
vonji, okusi = izloci_gnezdene_podatke(vina)
orod.zapisi_csv(vina, [
'id', 'ime', 'barva', 'letnik', 'drzava', 'regija', 'cena', 'alkohol',
'zaprtje', 'ocena'
], 'obdelani-podatki/vina.csv')
orod.zapisi_csv(vonji, ['vino', 'vonj'], 'obdelani-podatki/vonji.csv')
orod.zapisi_csv(okusi, ['vino', 'okus'], 'obdelani-podatki/okusi.csv')
stevec += 1
seznam_slovarjev = []
najdeni = 0
for ujemanje in re.finditer(vzorec_podatkov, vsebina):
najdeni += 1
seznam_slovarjev.append(ujemanje.groupdict())
def pocisti_podatke(seznam):
for slovar in seznam:
for i in ["st", "nd", "th", "rd"]:
slovar["mesto"] = slovar["mesto"].replace(i, '')
slovar["mesto"] = int(slovar["mesto"].replace(',', ''))
slovar["ocena"] = str(slovar["ocena"])
slovar["ime"] = slovar["ime"]
slovar["kategorija"] = slovar["kategorija"]
slovar["objave"] = int(slovar["objave"].replace(',', ''))
slovar["vpisani"] = float(slovar["vpisani"].replace('M', ''))
slovar["ogledi"] = int(slovar["ogledi"].replace(',', ''))
return seznam
print(najdeni)
print(stevec)
orodja.zapisi_json(bloki, 'obdelani-podatki/bloki.json')
orodja.zapisi_csv(pocisti_podatke(seznam_slovarjev), polja,
'obdelani-podatki/podatki.csv')
# v seznamu oglasi imam sedaj vse slovarje, ki predstavljajo posamezni oglas
# vsak slovar vsebuje ključe:
# id, tip, nadstropje, leto, opis, velikost,
# cena, agencija, obmocje, adaptirano
# popravimo ceno stanovanj, ki imajo napisano ceno na kvadratni meter
# in ne skupne cene
cena_kvadratni_meter = [
6085094, 6220910, 6180911, 6180912, 6219309, 6221462, 6208526, 6136686
]
for slovar in oglasi:
if slovar['id'] == 6217331:
slovar['velikost'] = 80.9
for id in cena_kvadratni_meter:
if slovar['id'] == id:
slovar['cena'] *= slovar['velikost']
# zapišem sedaj podatke v csv in razvrstim stolpce
orodja.zapisi_csv(oglasi, [
'id', 'obmocje', 'tip', 'leto', 'adaptirano', 'nadstropje', 'velikost',
'cena', 'agencija', 'opis'
], 'obdelani_podatki/stanovanja.csv')
# zapišem še v json datoteki za pregled
orodja.zapisi_json(oglasi, 'obdelani_podatki/stanovanja.json')
return izloci_podatke_oglasa(vsebina)
def izloci_podatke_oglasa(vsebina):
'''Naredi slovar glede na zgornji vzorec s pomočjo regularnih izrazov.'''
oglas = vzorec_podrobnosti.search(vsebina).groupdict()
return oglas
#orodja.shrani_spletno_stran(URL, 'zajeti-podatki/prosta-dela.html')
#vsebina = orodja.vsebina_datoteke('zajeti-podatki/prosta-dela.html')
#sifre = re.findall(vzorec_sifre, vsebina, flags=re.DOTALL)
sifre = []
for datoteka in os.listdir('zajeti-podatki'):
sifre.append(datoteka[19:25])
oglasi = []
for sifra in sifre:
oglasi.append(podrobnosti(sifra))
orodja.zapisi_json(oglasi, 'obdelani-podatki/oglasi.json')
orodja.zapisi_csv(oglasi, [
'delo', 'kraj', 'Regija', 'plačilo', 'naslov', 'datum_pričetka',
'delovnik', 'število_članov', 'trajanje', 'šifra', 'opis', 'podjetje'
], 'obdelani-podatki/oglasi.csv')
print(len(sifre))
print(len(oglasi))
def create_data(directory=folders.full_directory,
json=True,
csv=True,
delete_invalid=True):
anime_list = []
failed = []
for filename in os.listdir(directory):
content = orodja.vsebina_datoteke(os.path.join(directory, filename))
result = full_pattern.search(content)
if result:
anime_dict = clean_info(result.groupdict())
if anime_dict['rating'] != 'Rx - Hentai':
anime_list.append(anime_dict)
else:
print('Ups: ', filename)
else:
print('Failed: ', filename, ':\n', content)
failed.append(os.path.join(directory, filename))
if delete_invalid:
for file in failed:
os.remove(file)
anime_list.sort(key=lambda anime: anime['id'])
if json:
orodja.zapisi_json(anime_list, folders.json_name)
if csv:
producers, genres, studio_list, producer_list, genre_list = get_linked_lists(
anime_list)
orodja.zapisi_csv(anime_list, [
'id', 'title', 'score', 'airedfrom', 'airedto', 'episodes', 'type',
'status', 'source', 'rating', 'members', 'duration', 'rank',
'popularity', 'favorites', 'description'
], folders.csv_name)
orodja.zapisi_csv(producers, ['id', 'name'],
folders.csv_producers_name)
orodja.zapisi_csv(genres, ['id', 'name'], folders.csv_genres_name)
orodja.zapisi_csv(studio_list, ['studio', 'anime'],
folders.csv_linked_studios_name)
orodja.zapisi_csv(producer_list, ['anime', 'producer'],
folders.csv_linked_producers_name)
orodja.zapisi_csv(genre_list, ['anime', 'genre'],
folders.csv_linked_genres_name)
if [dictzadetek['naslov'], dictzadetek['izvajalec']
] not in [[videna['naslov'], videna['izvajalec']]
for videna in pesmi]:
videna = dictzadetek
videna['id'] = len(pesmi)
videna['tednov'] = 1
videna['povp_mesto'] = videna['mesto_na_lestvici']
videna['feat'] = ('Featuring' in videna['izvajalec']) or (
',' in videna['izvajalec']) or ('&' in videna['izvajalec'])
pesmi.append(videna)
else:
for videna in pesmi:
if [dictzadetek['naslov'], dictzadetek['izvajalec']
] == [videna['naslov'], videna['izvajalec']]:
videna['tednov_na_lestvici'] = max(
videna['tednov_na_lestvici'],
dictzadetek['tednov_na_lestvici'])
videna['najvišje_mesto'] = min(
videna['najvišje_mesto'],
dictzadetek['najvišje_mesto'])
videna['povp_mesto'] = (
videna['povp_mesto'] * videna['tednov'] +
dictzadetek['mesto_na_lestvici']) / (videna['tednov'] +
1)
videna['tednov'] += 1
o.zapisi_csv(pesmi, [
'id', 'mesto_na_lestvici', 'izvajalec', 'naslov', 'tednov_na_lestvici',
'najvišje_mesto', 'tednov', 'povp_mesto', 'feat'
], 'billboard.csv')
o.zapisi_json(pesmi, 'billboard.json')
"oglasi-oddaja/slovenija/"
f"stanovanje/{st_strani}/")
ime_datoteke = f"spletne-strani/stanovanja-{st_strani}.html"
orodja.shrani_spletno_stran(url, ime_datoteke)
vsebina = orodja.vsebina_datoteke(ime_datoteke)
for blok in vzorec_bloka.finditer(vsebina):
url2 = str(izloci_podatke_stanovanja(blok.group(0)).get("url"))
id = izloci_podatke_stanovanja(blok.group(0)).get("id")
drugo = dodatni_podatki_na_strani(url2, id)
stanovanje = izloci_podatke_stanovanja(blok.group(0))
stanovanje.update(drugo)
yield stanovanje
# for zanka, ki uporabi funkcijo stanovanje_na_strani na vsaki
# spletni strani in slovar s podatki oglasa doda v seznam stanovanja
stanovanja = []
for st_strani in range(1, 32):
for stanovanje in stanovanje_na_strani(st_strani):
stanovanja.append(stanovanje)
# csv datoteka
orodja.zapisi_csv(stanovanja, [
'id', 'regija', 'mesto', 'velikost', 'cena', 'tip', 'leto', 'adaptirano',
'nadstropje', 'agencija', 'opis', 'url'
], 'podatki/stanovanja.csv')
# json datoteka
orodja.zapisi_json(stanovanja, 'podatki/stanovanja.json')
oglas['cena'] = int(oglas['cena'])
#print(oglas['cena'])
except:
oglas['cena'] = int(float(oglas['cena']) * 1000)
#print(oglas['cena'])
#with ope#n('slovari.html', 'r', encoding='utf-8') as s:
# with open('slovarji_z_vejico.html', 'w', encoding='utf-8') as v:
# for vrstica in s:
# print(vrstica, end=',', file=v)
funkcija1('test.html', 'ocisceno.html')
zapise_v_json('olepsano.html', 'avti.json')
with open('ocisceno.html', 'r', encoding='utf-8') as f:
slovarji = f.read()
slovarji = ast.literal_eval(slovarji)
orodja.zapisi_csv(slovarji, [
'Znamka',
'Model',
'cena',
'Prevozeni Km',
'Prva registracija',
'gorivo',
'menjalnik',
'prostornina motorja',
'moc v KM',
'moc v KW',
'ID',
], 'avti.csv')
zaposleni.append(slovar)
return sredstva, prihodki, dobicki, zaposleni
firme = nalozi_firme()
for firma in firme:
dodaj_letosnje_podatke(firma)
dodaj_slovar_vecih_let(firma)
dodaj_podatke_zadnjih_let(firma)
uredi_podatke(firma)
orodja.zapisi_json(firme, 'Zajeti_podatki/firme.json')
sredstva, prihodki, dobicki, zaposleni = izloci_vec_letne_podatke(firme)
orodja.zapisi_csv(
firme,
[
'mesto', 'firma', 'sprememba_na_lestvici', 'direktor', 'drzava',
'sektor', 'industrija', 'leta_na_lestvici', 'prihodki',
'sprememba_prihodkov', 'dobicek', 'sprememba_dobicka', 'sredstva',
'zaposleni'
],
'Zajeti_podatki/firme.csv',
)
orodja.zapisi_csv(sredstva, ['firma', '2019', '2018', '2017', '2016'],
'Zajeti_podatki/vec_letna_sredstva.csv')
orodja.zapisi_csv(prihodki, ['firma', '2019', '2018', '2017', '2016'],
'Zajeti_podatki/vec_letni_prihodki.csv')
orodja.zapisi_csv(dobicki, ['firma', '2019', '2018', '2017', '2016'],
'Zajeti_podatki/vec_letni_dobicki.csv')
orodja.zapisi_csv(zaposleni, ['firma', '2019', '2018', '2017', '2016'],
'Zajeti_podatki/vec_letni_zaposleni.csv')
# tu sem zaj spremenila finditer v findall
def izlocimo_restavracije_s_strani(url):
podatki = []
orodja.shrani_spletno_stran(url, frontpage_filename)
vsebina = orodja.vsebina_datoteke(frontpage_filename)
for blok in vzorec_bloka.findall(vsebina):
podatki.append(izlocimo_podatke(blok))
return podatki
restavracije = []
for restavracija in izlocimo_restavracije_s_strani(prehrana_frontpage_url):
restavracije.append(restavracija)
restavracije.sort(key=lambda restavracija: restavracija['id'])
orodja.zapisi_json(restavracije, 'obdelani-podatki/restavracije.json')
lastnosti = izlocimo_gnezdene_podatke(restavracije)
orodja.zapisi_csv(restavracije,
['id', 'ime', 'naslov', 'kraj', 'cena_obroka', 'doplacilo'],
'obdelani-podatki/restavracije.csv')
orodja.zapisi_csv(lastnosti, ['restavracija', 'lastnost'],
'obdelani-podatki/lastnosti.csv')
vsebina = orodja.vsebina_datoteke(frontpage_filename)
# vsebina = orodja.vsebina_datoteke(frontpage_filename)
# for blok in vzorec_bloka.findall(vsebina):
# if vzorec_restavracije.search(blok) == None:
# print(blok)
ime_datoteke = f'htmlji/knjige-{st_strani}.html'
orodja.shrani_spletno_stran(url, ime_datoteke)
vsebina = orodja.vsebina_datoteke(ime_datoteke)
for blok in vzorec_bloka.finditer(vsebina):
yield izloci_podatke_knjige(blok.group(0))
knjige = []
for st_strani in range(1, 7):
for knjiga in knjige_na_strani(st_strani, 100):
knjige.append(knjiga)
knjige.sort(key=lambda ocena: knjiga['ocena'])
orodja.zapisi_csv(knjige, [
'id_knjiga', 'ime_knjiga', 'link', 'id_avtor', 'ime_avtor', 'ocena',
'stevilo_ocen', 'kljucna_ocena', 'stevilo_kritik'
], 'obdelani-podatki/knjige.csv')
def izloci_gnezdene_podatke(knjige):
avtorji, url_zanri = [], []
for knjiga in knjige:
avtorji.append({
'id_avtor': knjiga['id_avtor'],
'ime_avtor': knjiga['ime_avtor']
})
url_zanri.append(knjiga['link'])
return avtorji, url_zanri
###############################################################################
# Podatke zapišemo v json datoteko.
###############################################################################
orodja.zapisi_json(zapis_serij, 'vse_epizode.json')
###############################################################################
# Nato pa jih dokončno predelamo in zapišemo še v csv datoteke.
###############################################################################
zanri = izloci_zanre(zapis_serij)
vloge = izloci_reziserje(zapis_serij)
# Znebimo se nepotrebnih ponovitev zapisa žanrov posamezne serije
posodobi_zanre = []
for element in zanri:
if element not in posodobi_zanre:
posodobi_zanre.append(element)
zanri = posodobi_zanre
zapis_serij.sort(key=lambda epizoda: epizoda['id'])
orodja.zapisi_csv(
zapis_serij,
["id", "serija", "epizoda", "leto", "dolzina", "ocena", "st_glasov"],
'vse_epizode.csv')
orodja.zapisi_csv(vloge, ["id", "reziser"], 'reziserji.csv')
orodja.zapisi_csv(zanri, ["serija", "zanr"], 'zanri.csv')
sestavine = []
for recept in recepti:
for sestavina in recept.pop('sestavine'):
sestavine.append({
'recept': recept['naslov'],
'sestavina': sestavina
})
return sestavine
recepti = []
for crka in STEVILO_STRANI:
print(crka)
for datoteka in os.listdir('recepti/stran_receptov/' + crka):
with open('recepti/stran_receptov/' + crka + '/' + datoteka,
'r',
encoding='utf-8') as f:
blok = f.read()
recept = izloci_podatke_recepta(blok)
recepti.append(recept)
recepti.sort(key=lambda recepti: recepti['naslov'])
orodja.zapisi_json(recepti, 'obdelani-podatki/recepti.json')
sestavine = izloci_sestavine(recepti)
orodja.zapisi_csv(recepti, [
'naslov', 'avtor', 'cas_priprave', 'cas_kuhanja', 'stevilo_ocenjevalcev',
'ocena', 'dieta', 'zvrst'
], 'obdelani-podatki/recepti.csv')
orodja.zapisi_csv(sestavine, ['recept', 'sestavina'],
'obdelani-podatki/sestavine.csv')
for zanr in film.pop('zanri'):
zanri.append({'film': film['id'], 'zanr': zanr})
for mesto, oseba in enumerate(film.pop('reziserji'), 1):
dodaj_vlogo(film, oseba, REZISER, mesto)
for mesto, oseba in enumerate(film.pop('igralci'), 1):
dodaj_vlogo(film, oseba, IGRALEC, mesto)
osebe.sort(key=lambda oseba: oseba['id'])
vloge.sort(
key=lambda vloga: (vloga['film'], vloga['vloga'], vloga['mesto']))
zanri.sort(key=lambda zanr: (zanr['film'], zanr['zanr']))
return osebe, vloge, zanri
filmi = []
for st_strani in range(1, 41):
for film in filmi_na_strani(st_strani, 250):
filmi.append(film)
filmi.sort(key=lambda film: film['id'])
orodja.zapisi_json(filmi, 'obdelani-podatki/filmi.json')
osebe, vloge, zanri = izloci_gnezdene_podatke(filmi)
orodja.zapisi_csv(filmi, [
'id', 'naslov', 'dolzina', 'leto', 'ocena', 'metascore', 'glasovi',
'zasluzek', 'oznaka', 'opis'
], 'obdelani-podatki/filmi.csv')
orodja.zapisi_csv(osebe, ['id', 'ime'], 'obdelani-podatki/osebe.csv')
orodja.zapisi_csv(vloge, ['film', 'oseba', 'vloga', 'mesto'],
'obdelani-podatki/vloge.csv')
orodja.zapisi_csv(zanri, ['film', 'zanr'], 'obdelani-podatki/zanri.csv')
elif liga == "primera-division":
return 4
elif liga == "ligue-1":
return 5
ekipe = []
for drzava, liga in lige.items():
for ekipa in ekipe_iz_lige(drzava, liga):
podatki = izloci_podatke_ekipe(ekipa)
if podatki and podatki['id'] not in [ekipa['id'] for ekipa in ekipe]:
podatki["liga"] = id_lige(liga)
ekipe.append(podatki)
orodja.zapisi_csv(
ekipe, ['id', 'ime_ekipe', 'liga'], 'obdelani-podatki/klubi.csv'
)
orodja.zapisi_json(ekipe, 'obdelani-podatki/klubi.json')
lige_top5 = []
for drzava, liga in lige.items():
liga_i = {}
liga_i["id"] = id_lige(liga)
if drzava == "england" and liga == "premier-league":
liga_i["drzava"] = "Anglija"
liga_i["ime"] = "Premier League"
elif drzava == "italy" and liga == "serie-a":
liga_i["drzava"] = "Italija"
liga_i["ime"] = "Serie A"
elif drzava == "germany" and liga == "bundesliga":
#for i in range(0,80):
# orodja.pripravi_imenik(f'zajeti_podatki/{i+1}. stran.html')
# orodja.shrani_spletno_stran(f'https://money.cnn.com/data/markets/russell/?page={i}', f'zajeti_podatki/{i+1}. stran.html')
vzorec = (
r'<a class="wsod_symbol" href=".*?">(?P<Oznaka>\w{3,4})'
r'</a> (?P<Ime_podjetja>.+?)</td>'
r'<td><span stream="last_\d+" streamFeed="MorningstarQuote">'
r'(?P<Cena>.+?)</span></td><td><span stream="change_\d+" streamFeed="MorningstarQuote"><span class=".*?">'
r'(?P<Sprememba_cene>.+?)</span></span></td><td><span stream="changePct_\d+" streamFeed="MorningstarQuote"><span class=".*?">'
r'(?P<Sprememba_v_odstotkih>.+?)</span></span></td><td>'
r'(?P<PE_razmerje>.+?)</td><td>'
r'(?P<Stevilo_delnic>.+?)</td><td><span class=".*?">'
r'(?P<Sprememba_do_danes>.+?)<')
for i in range(0,80):
with open(f'zajeti_podatki/{i+1}. stran.html', encoding='utf8') as f:
vsebina = f.read()
zgreseni = 0
for zadetek in re.finditer(vzorec,vsebina):
slovar.append(zadetek.groupdict())
zgreseni = zgreseni + 1
zgreseni2 = 15 - zgreseni + zgreseni2
print(slovar, zgreseni2)
orodja.zapisi_csv(slovar, slovar[0].keys(),'podatki.csv')
vzorec2 = (
r'<div class="metascore_w large.*?>(?P<Metascore>.*)<(.*\n){8}<div class="metascore_w user.*>(?P<ocena_uporabnikov>.*)<'
)
stevec = 0
stevec2 = 0
for zadetek in re.finditer(vzorec, vsebina):
#print(zadetek.groupdict())
stevec += 1
slovar.append(zadetek.groupdict())
print(stevec)
for zadetek in re.finditer(vzorec2, vsebina):
slovar2.append(zadetek.groupdict())
stevec2 += 1
zgreseni += 100 - stevec
print(stevec2)
zgreseni2 += 100 - stevec2
orodja.zapisi_json(slovar, 'jsoni\podatki.json')
orodja.zapisi_csv(slovar, slovar[1].keys(), f'csvji\podatki.csv')
orodja.zapisi_json(slovar2, 'jsoni\ocene.json')
orodja.zapisi_csv(slovar2, slovar2[1].keys(), f'csvji\ocene.csv')
print(zgreseni)
print(zgreseni2)
'id_lige': id_lige,
'liga': liga,
'id_kluba': id_kluba,
'klub': klub
})
klubi.sort(key=lambda klub: (klub['id_lige'], klub['id_kluba']))
return klubi
igralci = []
# Ker sem odstranil igralce s ceno 0 (z razlago glej nižje) sem moral spremeniti loop, da dosežem kvoto 3000 igralcev
stevec = 1
st_strani = 1
while stevec <= 3000:
for igralec in obdelava_spletne_strani(st_strani):
# Zaradi lažje obdelave podatkov odstranim vse igralce s ceno 0
# OPOMBA: igralci s ceno 0 v igri ne obstajajo, na spletni strani so objavljeni le zato, ker so pred izidom igre menjali klub!
if igralec['cena'] != 0 and stevec <= 3000:
igralci.append(igralec)
stevec += 1
st_strani += 1
igralci.sort(key=lambda igralec: igralec['id'])
orodja.zapisi_json(igralci, 'igralci.json')
# Zaradi preglednost CSV datoteke odstranim nekatere stolpce, ki so razvidni z id_lige
klubi = izloci_klub(igralci)
nova_imena_polj = [
i for i in imena_polj if i not in ('klub', 'id_lige', 'liga')
]
orodja.zapisi_csv(igralci, nova_imena_polj, 'igralci.csv')
orodja.zapisi_csv(klubi, ['id_lige', 'liga', 'id_kluba', 'klub'], 'klubi.csv')
orodja.shrani_spletno_stran(url, ime_datoteke)
vsebina = orodja.vsebina_datoteke(ime_datoteke)
for blok in vzorec_bloka.finditer(vsebina):
yield izloci_podatke_igralca(blok.group(0))
def izloci_gnezdene_podatke(igralci):
polozaj1 = []
for igralec in igralci:
for polozaj in igralec.pop('polozaj1'):
polozaj1.append({'igralec': igralec['id'], 'polozaj': polozaj})
polozaj1.sort(key=lambda polozaj: (polozaj['igralec'], polozaj['polozaj']))
return polozaj1
igralci = []
for st_strani in range(1, 171):
for igralec in igralci_na_strani(st_strani):
igralci.append(igralec)
igralci.sort(key=lambda igralec: igralec['id'])
orodja.zapisi_json(igralci, 'obdelani-podatki/igralci.json')
polozaj1 = izloci_gnezdene_podatke(igralci)
orodja.zapisi_csv(igralci, [
'id', 'ime_in_priimek', 'državljanstvo', 'ocena', 'potencial', 'starost',
'iskanja', 'klub'
], 'obdelani-podatki/igralci.csv')
orodja.zapisi_csv(polozaj1, ['igralec', 'polozaj'],
'obdelani-podatki/polozaji.csv')
# upoštevamo, da so datoteke v večih direktorijih
for direktorij in os.listdir('zajete_strani/oglasi'):
if direktorij != '.DS_Store':
for oglas in os.listdir(f'zajete_strani/oglasi/{direktorij}'):
detajli = izloci_detajle(
orodja.vsebina_datoteke(f'zajete_strani/oglasi/{direktorij}/{oglas}'))
if detajli:
detajli['popularnost'] = re.sub('[^0-9]', '', oglas) # isluščimo zaporedno številko
slovarji_detajlov.append(detajli)
okusi = izloci_iz_seznama(
vzorec_okusov, orodja.vsebina_datoteke(f'zajete_strani/oglasi/{direktorij}/{oglas}'))
vonjave = izloci_iz_seznama(
vzorec_vonjav, orodja.vsebina_datoteke(f'zajete_strani/oglasi/{direktorij}/{oglas}'))
if okusi:
slovarji_okusov += okusi
if vonjave:
slovarji_vonjav += vonjave
# zapišemo CSV-je
orodja.zapisi_csv(slovarji_vin, slovarji_vin[0].keys(), 'obdelani_podatki/vina.csv')
orodja.zapisi_csv(
slovarji_detajlov,
['id', 'regija', 'podregija', 'barva', 'alkohol', 'zamasek', 'opis', 'recenzija', 'popularnost'],
'obdelani_podatki/detajli.csv')
orodja.zapisi_csv(slovarji_okusov, ['id', 'okus'], 'obdelani_podatki/okusi.csv')
orodja.zapisi_csv(slovarji_vonjav, ['id', 'vonj'], 'obdelani_podatki/vonjave.csv')
