def vsa_tekmovanja(začetek, konec):
osnovni_link = "https://www.imo-official.org/"
tekmovanja = []
for leto in range(zacetek, konec):
tekmovanje_leto = []
#Za leto 1980 ni podatkov.
if leto == 1980:
continue
url = f'https://www.imo-official.org/year_country_r.aspx?year={leto}'
ime_datoteke_html = f'zajeti_podatki/leto_{leto}/imo-{leto}.html'
orodja.shrani_spletno_stran(url, ime_datoteke_html)
vsebina = orodja.vsebina_datoteke(
f'zajeti_podatki/leto_{leto}/imo-{leto}.html')
for link in vzorec_leto.finditer(vsebina):
tekmovanje_leto.append({
"leto":
leto,
"država":
link.groupdict()["država"],
"link":
osnovni_link + link.groupdict()["link1"] +
link.groupdict()["link2"]
})
# Shranim v json
ime_datoteke_json = f'zajeti_podatki/leto_{leto}/imo-{leto}.json'
orodja.zapisi_json(tekmovanje_leto, ime_datoteke_json)
tekmovanja.extend(tekmovanje_leto)
return tekmovanja
def podatki_v_json(potrditev_iskanja_podatkov, stevilo_strani, mapa_podatkov, ime_json_datoteke):
'''Izlušči podatke iz vseh prenešenih strani in jih shrani v JSON datoteko.'''
if potrditev_iskanja_podatkov:
seznam_podatkov = []
for i in range(stevilo_strani):
podatki = podatki_s_strani(mapa_podatkov, f"igre_od_{i * 100}_do_{i * 100 + 99}.html")
seznam_podatkov += podatki
orodja.zapisi_json(seznam_podatkov, ime_json_datoteke)
print("Podatki so bili uspešno pridobljeni!")
def pridobi_podatke_o_oglasih(ime_datoteke):
seznam_oglasov = posamezni_oglasi(ime_datoteke) #seznam po oglasih
slovar_iskanih_podatkov = []
stevec = 0
for i in seznam_oglasov:
for zadetek in re.finditer(vzorec_oglasa, i):
slovar_zadetkov = zadetek.groupdict()
slovar_iskanih_podatkov.append(slovar_zadetkov)
stevec += 1
print(stevec, slovar_iskanih_podatkov)
#orodja.zapisi_csv(slovar_iskanih_podatkov, ['naslov', 'podnaslov', 'neto_placa', 'bruto_placa', 'lokacija', 'opis', 'stevilo_mest', 'trajanje', 'delovnik', 'sifra', 'narava_dela'], 'prosta_dela1.csv')
#print('končano:', len(slovar_iskanih_podatkov))
orodja.zapisi_json(slovar_iskanih_podatkov, 'prosta_dela2.json')
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(datoteka):
''' glavna funkcija, kateri podamo json datoteko s seznamom slovarjev podjetij
za vsako podjetje poišče pot ter lokacijo, podatke doda in jih zapiše nazaj
v isto datoteko. '''
# odpre brskalnik firefox
driver = webdriver.Firefox()
# nalozi stran na kateri zbiramo podatke
driver.get(zemljevid_stran)
podjetja = nalozi_podjetja(orodja.nalozi_json(datoteka))
try:
podjetja = doloci_poti(driver, podjetja)
except:
pass
podjetja = [podjetje.json_oblika() for podjetje in podjetja]
orodja.zapisi_json(podjetja, datoteka)
# zapre brskalnik
driver.close()
def obdelaj_json():
neobdelani = orodja.nalozi_json(poizvedba.path_json)
if orodja.ne_obstaja(zacasni_json):
obdelani = {}
else:
obdelani = orodja.nalozi_json(zacasni_json)
for slovar_podatkov in neobdelani:
id_osebe = wiki.id(slovar_podatkov["id"]["value"])
if id_osebe in obdelani:
continue
else:
obdelani[id_osebe] = predelaj_slovar(slovar_podatkov)
orodja.zapisi_json(zacasni_json, obdelani)
print("Obdelani podatki za: {} ({}%)".format(slovar_podatkov["ime"]["value"], len(obdelani) * 100 // len(neobdelani)))
seznam_vseh = [filtriraj(podatek) for podatek in obdelani.values() if slovensko_ime(podatek["Ime"])]
seznam_vseh.sort(key = lambda podatek: podatek["ID"])
orodja.zapisi_json(novi_json, seznam_vseh)
print("Končano")
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)
oglasi_na_strani(stran)
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",
)
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)
def zapisi_json(dat_json, dat_sparqul):
poizvedba = orodja.preberi(dat_rq)
rezultati = rezultat("https://query.wikidata.org/sparql", poizvedba)
orodja.zapisi_json(dat_json, rezultati)
def ustvari_json():
orodja.zapisi_json(
vsi_seti,
"/Users/thrawn/Documents/git/Lego-sets/obdelani-podatki/bricksets-database-1999-2019.json"
)
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')
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')
def zapise_v_json(vhodna, izhodna):
'''zapise v json datoteko s pomocjo orodij, v vhodni datoteki morajo biti podatki v slovarjih, locenih z vejico'''
with open(vhodna, 'r', encoding='utf-8') as s:
objekt = s.read()
objekt = ast.literal_eval(objekt)
orodja.zapisi_json(objekt, izhodna)
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')
'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')
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')
def main():
pridobi_stran("https://www.suredividend.com/russell-2000-stocks/")
final = pridobi_podatke()
orodja.zapisi_json(final, "C:\\Users\\jansk\\Documents\\GitHub\\Delnice-Russel-2000\\stran\\jsonfile.json" )
orodja.zapisi_csv(final, final[0].keys(), "C:\\Users\\jansk\\Documents\\GitHub\\Delnice-Russel-2000\\stran\\csv_file.csv")
slovar.update({key: drugi_slovar[key] for key in drugi_slovar})
dobicki.append(slovar)
slovar = {'firma': firma['firma']}
drugi_slovar = firma.pop('vec_letni_zaposleni')
slovar.update({key: drugi_slovar[key] for key in drugi_slovar})
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')
"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')
# 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')
podatki['st_glasov'] = int(podatki['st_glasov'].replace(',', ''))
return podatki
zapis_serij = []
razbitje = poisci_epizode(besedilo)
for i in range(0, len(razbitje)):
for ujemanje in vzorec_epizode.finditer(razbitje[i]):
podatki_epizode = pocisti_podatke(ujemanje.groupdict())
zapis_serij.append(podatki_epizode)
###############################################################################
# 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)
import orodja
filmov_na_stran = 50
stevilo_filmov = 200
vzorec = (
r'<a href="/title/tt'
r'(?P<id>\d{7})' # ID ima sedem števk
r'/(\?ref_=adv_li_tt)?"\n>' # neka šara vmes med id-jem in naslovom
r'(?P<naslov>.*?)' # zajamemo naslov
r'</a>'
r'\s+'
r'<span class="lister-item-year text-muted unbold">\('
r'(?P<leto>\d{4})'
r'\)')
count = 0
filmi = []
for start in range(1, stevilo_filmov, filmov_na_stran):
url = ('https://www.imdb.com/search/title/?'
'title_type=feature&sort=num_votes,desc&'
f'count={filmov_na_stran}&start={start}')
ime_datoteke = f'filmi-{start}-{start + filmov_na_stran - 1}.html'
orodja.shrani_spletno_stran(url, ime_datoteke)
vsebina = orodja.vsebina_datoteke(ime_datoteke)
for zadetek in re.finditer(vzorec, vsebina):
filmi.append(zadetek.groupdict())
count += 1
orodja.zapisi_json(filmi, 'filmi.json')
knjiga['avtor'] = knjiga['avtor'].replace("'", "'").replace("&", "&").replace(""", "'")
knjiga['naslov'] = knjiga['naslov'].replace("'", "'").replace("&", "&").replace(""", "'")
knjiga['ocena'] = float(knjiga['ocena'])
knjiga['stevilo_ocen'] = int(knjiga['stevilo_ocen'].replace(',', ''))
knjiga['leto'] = int(knjiga['leto'])
knjiga['glasovi'] = int(knjiga['glasovi'].replace(',', ''))
zbirka = vzorec_zbirke.search(blok)
if zbirka:
knjiga['zbirka'] = knjiga['zbirka'].replace("&", "&")
if knjiga['zbirka'][-1] == ',':
knjiga['zbirka'] = knjiga['zbirka'][:-1]
else:
knjiga['zbirka'] = None
return knjiga
def ena_stran(stevilka):
url=f'https://www.goodreads.com/book/popular_by_date/{stevilka}/'
datoteka = f'najbolj-popularne-knjige/{stevilka}.html'
orodja.shrani_spletno_stran(url, datoteka)
vsebina = orodja.vsebina_datoteke(datoteka)
for blok in vzorec_bloka.finditer(vsebina):
yield spremeni(blok.group(0))
seznam = []
for stevilka_leta in range(1920, 2021):
for i in ena_stran(stevilka_leta):
seznam.append(i)
orodja.zapisi_json(seznam, 'obdelani-podatki/knjige.json')
orodja.zapisi_csv(seznam, ['id', 'naslov', 'zbirka', 'id_avtorja', 'avtor', 'ocena', 'stevilo_ocen', 'leto', 'glasovi'], 'obdelani-podatki/knjige.csv')
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":
liga_i["drzava"] = "Nemčija"
liga_i["ime"] = "Bundesliga"
elif drzava == "spain" and liga == "primera-division":
# 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)
] 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')
return osebe, zanri, nagrade, avtorji
knjige = []
count = 1
for st_strani in range(1, 6):
for blok in obdelaj_glavna_stran(st_strani):
for knjiga in obdelaj_knjige(count):
knjige.append(knjiga)
knjige[count - 1]['glasovi'] = blok['glasovi']
knjige[count - 1]['score'] = blok['score']
count += 1
knjige.sort(key=lambda knjiga: knjiga['id'])
orodja.zapisi_json(knjige, 'obdelani-podatki/knjige.json')
osebe, zanri, nagrade, avtorji = izloci_gnezdene_podatke(knjige)
orodja.zapisi_csv(knjige, [
'id', 'naslov', 'dolzina', 'leto', 'leto_original', 'score', 'glasovi',
'avgrating', 'ratings', 'reviews'
], 'obdelani-podatki/knjige.csv')
orodja.zapisi_csv(osebe, ['id_osebe', 'ime', 'starost', 'leto_rojstva'],
'obdelani-podatki/osebe.csv')
orodja.zapisi_csv(nagrade, ['knjiga', 'nagrada'],
'obdelani-podatki/nagrade.csv')
orodja.zapisi_csv(zanri, ['knjiga', 'zanr'], 'obdelani-podatki/zanri.csv')
orodja.zapisi_csv(avtorji, ['knjiga', 'oseba'], 'obdelani-podatki/avtorji.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')
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))
