def grange(st, ime):
rec=0
ImamZadetke=True
#global tekme
while ImamZadetke:
orodja.shrani('http://data.fis-ski.com/dynamic/athlete-biography.html?sector=AL&listid=&competitorid={}&type=result&category=WC&rec_start={}&limit=100'.format(st,rec), 'zajete-strani/{}{}.html'.format(ime,rec))
if rec == 0:
rezultat = re.search(r'Skis:.*?>[^>]*>(?P<smuci>[^<]*)', orodja.vsebina_datoteke('zajete-strani/{}{}.html'.format(ime,rec)))
rez=re.search(r'Nation:.*\n\W*.*?>.*?>.*?>.*?>(?P<drzava>.+?)<.span>', orodja.vsebina_datoteke('zajete-strani/{}{}.html'.format(ime,rec)))
if rezultat is None:
ski='Ni_podatka'
else:
ski = rezultat.group('smuci')
tekmovalci.append({'id':st, 'ime':ime, 'drzava': rez.group('drzava'), 'smuci': ski})
tekma = re.compile(
#r'<tr><td class=.i[01].>(?P<datum>.*?) <.td>'
r'<tr><td class=.i[01].>(?P<datum>.*?) <.td>\n<td class=.i[01].><a href=.+?>(?P<kraj>.+?)<.a><.td>\n.*\n.*\n.*?>(?P<disciplina>.+?)&.*\n<td class.*?>(?P<uvrstitev>.+?) <.td>\n<td .+?>'
)
for vnos in re.finditer(tekma, orodja.vsebina_datoteke('zajete-strani/{}{}.html'.format(ime,rec))):
datum='{}'.format(vnos.group('datum'))
kraj='{}'.format(vnos.group('kraj'))
disciplina='{}'.format(vnos.group('disciplina'))
mesto='{}'.format(vnos.group('uvrstitev'))
tekme.append({'datum': datum, 'kraj': kraj, 'mesto': mesto, 'disciplina': disciplina})
vse.append({'datum': datum, 'kraj': kraj, 'mesto': mesto, 'disciplina': disciplina, 'id': st})
#print (rec)
rec+=100
ImamZadetke=(len (tekme) == rec)
#print (ImamZadetke, len (tekme))
orodja.zapisi_tabelo(tekme,['datum', 'kraj', 'disciplina', 'mesto'], 'csv-datoteke/{}.csv'.format(ime))
def pripravi_bwin(potdatoteke = datum):
reg_sportnika = re.compile(r'<td class="option option_(.*?)" >'
r'[^я]*?<span class="option-name">(?P<sportnik>.*?) \((?P<drzava>.*?)\)</span>'
r'[^я]*?<span class="odds">(?P<kvota>.*?)</span>')
reg_dogodka = re.compile(r'.*<a class="league-link" href=".*" >(?P<dogodek>.*.)\n* *- (?P<drzava>.*)</a>')
#r'.*<a class="league-link" href=".*" >(?P<dogodek>.*.\n.*)</a>')
reg_datumi = re.compile(r'(?P<vse><h2 class="event-group-level3">[^Я]*? *.* - (?P<datum>.*)[^Я]*?<div class="ui-widget-content-body)')
###############################################################
#Tole je preveč. Treba je iti korak za korakom. #
###############################################################
#reg_datumi = re.compile(r'<h2 class="event-group-level3">[^Я]*? *.* - (?P<datum>.*)[^Я]*?</h2>'
# r'[^Я]*?<a class="league-link" href="(.*)[^Я]*? - (?P<kategorija>.*)</a>'
# r'[^Я]*?<h6 class="event-info">[^Я]*? *(?P<kraj>.*)[^Я]*?<td class="option option_'
# r'(.*?)" >'
# r'[^я]*?<span class="option-name">(?P<sportnik>.*?).\((?P<drzava>.*?)\)</span>'
# r'[^я]*?<span class="odds">(?P<kvota>.*?)</span>'
# r'[^я]*</html>')
reg_celatabela = re.compile(
r'<a class="league-link" href=".*" >(?P<dogodek>[^Я]*?)</a>[^я]*?<span class="option-name">'
r'(?P<sportnik>.*?) \((?P<drzava>.*?)\)</span>[^Я]*?<span class="odds">(?P<kvota>.*)'
r'</span>[^я]*?(<a class="league-link" href=|<div class="ui-widget-content" id="sport-footer">)'
)
igralci_surovo = []
dogodki = []
igralci = []
kategorije = []
for html_datoteka in orodja.datoteke('zajete-strani/' + potdatoteke + '/bwin/'):
datoteka = 'zajete-strani/' + potdatoteke + '/' + html_datoteka
csvDat = 'csv-datoteke/'+ html_datoteka[13:-5]
for ujemanje in re.finditer(reg_datumi, orodja.vsebina_datoteke(html_datoteka)):
#print(uredi_datum(ujemanje.group('vse'), ujemanje.group('datum')))
#print(ujemanje.groupdict())
if uredi_datum(ujemanje.group('vse'), ujemanje.group('datum')) != {}:
kategorije += [uredi_datum(ujemanje.group('vse'), ujemanje.group('datum'))]
orodja.zapisi_tabelo(kategorije, ['datum', 'kategorija'], csvDat + '/kategorije.csv')
for ujemanje in re.finditer(reg_celatabela, orodja.vsebina_datoteke(html_datoteka)):
igralci += [ujemanje.groupdict()]
orodja.zapisi_tabelo(igralci, ['dogodek', 'kvota', 'drzava','sportnik'], csvDat + '/sportniki.csv')
for ujemanje in re.finditer(reg_dogodka, orodja.vsebina_datoteke(html_datoteka)):
dogodki += [ujemanje.groupdict()]
orodja.zapisi_tabelo(dogodki, ['dogodek', 'drzava'], csvDat + '/dogodki.csv')
#
for ujemanje in re.finditer(reg_sportnika, orodja.vsebina_datoteke(html_datoteka)):
#print(ujemanje.groupdict())
igralci_surovo += [ujemanje.groupdict()]
orodja.zapisi_tabelo(igralci_surovo, ['sportnik', 'drzava', 'kvota'], csvDat + '/sportniki_surovo.csv')
def izloci_podatke(imenik):
potresi = []
for html_datoteka in orodja.datoteke(imenik):
for potres in re.finditer(regex_potresa,
orodja.vsebina_datoteke(html_datoteka)):
potresi.append(pocisti(potres))
return potresi
def izloci_podatke_gora(imenik):
regex_gore = re.compile(
r'<td class="naslov1"><b> <h1>(?P<ime>.*?)</h1></b></td>.*?'
r'<tr><td><b>Država:</b> <a class=moder href=/gore/.+?/\d>(?P<država>.*?)</a></td></tr>.*?'
r'<tr><td><b>Gorovje:</b> <a class="moder" href="/gorovje/.*?/\d{1,3}">(?P<gorovje>.*?)</a></td></tr>.*?'
r'<tr><td><b>Višina:</b> (?P<višina>\d+?) m</td></tr>.*?'
r'<tr><td><b>Širina/Dolžina:</b> <a class="moder" href="/zemljevid\.asp\?goraid=(?P<id>\d*?)">.*?'
r'<tr><td><b>Vrsta:</b> (?P<vrsta>.*?)</td></tr>.*?'
r'<tr><td><b>Ogledov:</b> (?P<st_ogledov>\d*?)</td></tr>.*?'
r'<tr><td><b>Priljubljenost:</b> \d+% \((?P<priljubljenost>\d+). mesto\)</td></tr>.*?'
r'<tr><td><b>Število poti:</b> <a class="moder" href="#poti">(?P<st_poti>\d*?)</a></td></tr>.*?'
r'<tr><td><b>Število GPS sledi:</b> <a class="moder" href="/gps.asp">(?P<st_GPS_sledi>\d+)</a></td></tr>.*?'
r"href='/izlet/.*?'>(?P<nakljucna_pot>.*?) .*?</a></td><td><a.*?"
r"href='/izlet/.*?>(?P<cas_hoje>.*?)</a></td><td><a.*?"
r"href='/izlet/.*?'>(?P<zahtevnost_poti>.*?)</a></td><td>.*?",
flags=re.DOTALL)
gore = []
for html_datoteka in orodja.datoteke(imenik):
for gora in re.finditer(regex_gore,
orodja.vsebina_datoteke(html_datoteka)):
gore.append(pocisti_goro(gora))
print(gore)
orodja.zapisi_tabelo(gore, [
'ime', 'država', 'gorovje', 'višina', 'id', 'vrsta', 'st_ogledov',
'priljubljenost', 'st_poti', 'st_GPS_sledi', 'nakljucna_pot',
'cas_hoje', 'zahtevnost_poti'
], 'gore.csv')
def shrani_zanre(mapa):
for zanr in mapa:
print(zanr)
vsebina = orodja.vsebina_datoteke(zanr)
podatki2 = {'opis': None}
for vzorec1 in re.finditer(vzorec_ime_zanra, vsebina):
podatki1 = vzorec1.groupdict()
for vzorec2 in re.finditer(vzorec_opis_zanr, vsebina):
podatki2 = vzorec2.groupdict()
if podatki2['opis_dolg'] is None: #Opis je takratek
podatki2['opis'] = orodja.pocisti_niz(
html.unescape(podatki2["opis"]))
else:
podatki2['opis'] = orodja.pocisti_niz(
html.unescape(podatki2["opis_dolg"]))
###CSV za zanr
podatkiZanr = dict()
zajeti_zanr = html.unescape(podatki1['ime_zanra'])
if not zajeti_zanr in zanri_za_popravit.keys():
podatkiZanr['ime_zanra'] = zajeti_zanr
podatkiZanr['opis'] = podatki2['opis']
seznam_vseh_zanrov.append(podatkiZanr)
else:
print('Nisem dodal {}'.format(zajeti_zanr))
#shrani_zanre(mapa)
#orodja.zapisi_tabelo(seznam_vseh_zanrov,
# ['ime_zanra', 'opis'],
# 'podatki/zanr.csv')
def igralci_na_strani():
ime_datoteke = 'podatki.html'
vsebina = orodja.vsebina_datoteke(ime_datoteke)
igralci = []
for blok in bloki.finditer(vsebina):
igralci.append(blok.group(0))
return igralci
def izloci_podatke_aplikacij(imenik):
aplikacije = []
for html_datoteka in orodja.datoteke(imenik):
for aplikacija in re.finditer(regex_aplikacije,
orodja.vsebina_datoteke(html_datoteka)):
aplikacije.append(pocisti_aplikacijo(aplikacija))
return aplikacije
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
def get_cvs():
regex_competitors = re.compile(
r'<tr.*?><td><a href="participant_r\.aspx\?id=(?P<id>\d+?)">(?P<Name>.*?)</a>.*?'
r'href="country_individual_r\.aspx\?code=(?P<Short_country_name>.*?)">(?P<Full_country_name>.*?)</a>.*?'
r'align="center">(?P<P1>.*?)</td><td align="center">(?P<P2>.*?)</td><td align="center">(?P<P3>.*?)</td>'
r'<td align="center">(?P<P4>.*?)</td><td align="center">(?P<P5>.*?)</td><td align="center">(?P<P6>.*?)</td>'
r'<td align="right">(?P<Points>.*?)</td><td align="right">(?P<Rank>.*?)</td><td>(?P<Achievement>.*?)</td></tr>',
flags=re.DOTALL)
matchings = []
for year in orodja.datoteke('podatki'):
for cats in re.finditer(regex_competitors,
orodja.vsebina_datoteke(year)):
cat = cats.groupdict()
cat['id'] = int(cat['id'])
for i in range(1, 7):
name = 'P{}'.format(i)
cat[name] = int(cat[name])
cat['Points'] = int(cat['Points'])
cat['Rank'] = int(cat['Rank'])
cat['Year'] = int(os.path.split(year)[1])
matchings.append(cat)
orodja.zapisi_tabelo(matchings, [
'id', 'Name', 'Short_country_name', 'Full_country_name', 'P1', 'P2',
'P3', 'P4', 'P5', 'P6', 'Points', 'Rank', 'Year', 'Achievement'
], 'data.csv')
def tekma_i_iz_lige(stevilka, liga):
ime_datoteke = 'spletne-strani-tekem/{}-{}.html'.format(liga, stevilka)
vsebina = orodja.vsebina_datoteke(ime_datoteke)
ekipe = []
for blok in vzorec_bloka.finditer(vsebina):
ekipe.append(blok.group(0))
return ekipe
def igralci_na_strani(st_strani):
url = f'https://www.fifaindex.com/players/{st_strani}/?gender=male&order=desc'
ime_datoteke = 'zajeti-podatki/igralci{}.html'.format(st_strani)
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_podatke_receptov(imenik):
recepti = []
for html_datoteka in orodja.datoteke(imenik):
for recept in re.finditer(regex_recepta,
orodja.vsebina_datoteke(html_datoteka)):
recepti.append(pocisti_recept(recept))
return recepti
def ekipe_iz_lige(drzava, liga):
ime_datoteke = 'spletne-strani/{}-{}.html'.format(drzava, liga)
vsebina = orodja.vsebina_datoteke(ime_datoteke)
ekipe = []
for blok in vzorec_bloka.finditer(vsebina):
ekipe.append(blok.group(0))
return ekipe
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))
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 leto_drzava_gostiteljica():
url = "https://www.imo-official.org/results_year.aspx"
ime_datoteke_html = 'zajeti_podatki/leto_gostiteljica.html'
orodja.shrani_spletno_stran(url, ime_datoteke_html)
vsebina = orodja.vsebina_datoteke(ime_datoteke_html)
for leto_drzava in vzorec_leto_gostiteljica.finditer(vsebina):
yield leto_drzava.groupdict()
def shrani_serije(mapa):
for serija in mapa:
vsebina = orodja.vsebina_datoteke(serija)
for vzorec in re.finditer(vzorec_ime_serije, vsebina):
podatki_serija = vzorec.groupdict()
for vzorec in re.finditer(vzorec_knjige_v_seriji, vsebina):
knjiga = vzorec.groupdict()
if knjiga['id_knjige'] not in idji_knjig and (
knjiga['serija'] == podatki_serija['ime']):
naslov = re.sub('[:|/|?]', '-', knjiga['naslov'])
urlji_knjig_iz_serij.append(
(knjiga['kratki_url'], naslov + knjiga['id_knjige']))
seznam_serija_knjiga.append({
'id_knjige':
knjiga['id_knjige'],
'id_serije':
serija.split('.')[0].split('\\')[-1],
'zaporedna_stevilka_serije':
knjiga['zaporedna_st']
})
# CSV datoteka serija: - naslov se je dodal že prej
podatki_serija['id'] = serija.split('.')[0].split('\\')[-1]
idji_serij.add(podatki_serija['id'])
seznam_vseh_serij.append(podatki_serija)
def izloci_podatke_kategorij(imenik):
kategorije = []
for html_datoteka in orodja.datoteke(imenik):
for kategorija in re.finditer(regex_kategorije,
orodja.vsebina_datoteke(html_datoteka)):
kategorije.append(pocisti_kategorije(kategorija))
return kategorije
def podrobnosti(sifra):
'''Shrani oglas z dano šifro, prebere vsebino danega oglasa in naredi slovar glede na zgornji vzorec s pomočjo regularnih izrazov.'''
url = (f'https://www.studentski-servis.com'
f'/ess/podrobnosti.php?id={sifra}')
ime_datoteke = 'zajeti-podatki/podrobnosti-oglasa.{}.html'.format(sifra)
orodja.shrani_spletno_stran(url, ime_datoteke)
vsebina = orodja.vsebina_datoteke(ime_datoteke)
return izloci_podatke_oglasa(vsebina)
def dodaj_letosnje_podatke(firma):
ime_datoteke = 'Spletne_strani/Firme/' + firma[
'poenostavljeno'] + '/2019.html'
orodja.shrani_spletno_stran(firma['link'], ime_datoteke)
vsebina_strani = orodja.vsebina_datoteke(ime_datoteke)
for zadetek in re.finditer(vzorec_na_strani, vsebina_strani):
podatki_firme = zadetek.groupdict()
firma.update(podatki_firme)
def placa(st_strani):
igralci = []
for i in range(1, st_strani + 1):
ime = 'podatki/place{}'.format(i)
vsebina1 = orodja.vsebina_datoteke(ime)
for blok in bloki_za_place.finditer(vsebina1):
igralci.append(blok.group(0))
return igralci
def zanri_url(seznam):
for konec in seznam:
url = ('https://www.goodreads.com/book/show/' f'{konec}')
ime_datoteke = f'htmlji-knjig-posebej/{konec}.html'
orodja.shrani_spletno_stran(url, ime_datoteke)
vsebina = orodja.vsebina_datoteke(ime_datoteke)
blok = re.finditer(vzorec_zanra, vsebina)
print(blok)
def najdi_studio(datoteka):
studiji = []
vsebina = orodja.vsebina_datoteke(datoteka)
for s in re.finditer(vzorec_studija, vsebina):
studio = s.groupdict()
studio['studio'] = studio['studio'].replace(''', "'")
studiji.append(studio)
return studiji
def najdi_sezono(datoteka):
vsebina = orodja.vsebina_datoteke(datoteka)
for s in re.finditer(vzorec_sezone, vsebina):
sezona = s.groupdict()
if sezona['sezona'] == '?':
return None
else:
return sezona['sezona'][:-5]
def izloci_rezultate(imenik, regex):
'''Vrne seznam s slovarji podatkov iz imenika'''
podatki = []
for datoteka in orodja.datoteke(imenik):
for podatek in re.finditer(regex, orodja.vsebina_datoteke(datoteka)):
pod = podatek.groupdict()
pod['Leto'] = int(pod['Leto'])
podatki.append(pod)
return podatki
def skladbe_na_strani(st_strani):
url = ('https://www.rollingstone.com/music/music-lists/'
'500-greatest-songs-of-all-time-151127/'
'?list_page={}').format(st_strani)
ime_datoteke = 'zajeti-podatki/top-skladbe-{}.html'.format(st_strani)
#orodja.shrani_spletno_stran(url, ime_datoteke)
vsebina = orodja.vsebina_datoteke(ime_datoteke)
for blok in vzorec_bloka.finditer(vsebina):
yield izloci_podatke_skladbe(blok.group(0))
def knjige_na_strani(st_strani):
url = (
f'https://www.goodreads.com/list/show/133723.Goodreads_Choice_Awards_2019_eligible_for_write_in_only_?page={st_strani}'
)
ime_datoteke = 'knjige-na-strani-{}.html'.format(st_strani)
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))
def knjige_na_strani(st_strani, na_stran=100):
url = ('https://www.goodreads.com/list/show/'
'1.Best_Books_Ever?'
f'page={st_strani}')
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))
def poberi_tedensko_lestvico(datum):
leto = datum.year
mesec = datum.month
dan = datum.day
url = f'http://world.kbs.co.kr/service/musictop10.htm?lang=e&start_year={leto}&rank_date={leto}-{mesec}-{dan}'
datoteka = f'kpop-lestvice/{leto}-{mesec}-{dan}.html'
orodja.shrani_spletno_stran(url, datoteka)
vsebina = orodja.vsebina_datoteke(datoteka)
for blok in vzorec_bloka.finditer(vsebina):
yield izlusci_podatke_pesmi(blok.group(0))
def filmi_na_strani(st_strani, na_stran=250):
url = (f'https://www.imdb.com/search/title'
f'?sort=num_votes,desc&title_type=feature&count={na_stran}'
f'&start={(st_strani - 1) * na_stran + 1}')
ime_datoteke = 'zajeti-podatki/najbolj-znani-filmi-{}.html'.format(
st_strani)
orodja.shrani_spletno_stran(url, ime_datoteke)
vsebina = orodja.vsebina_datoteke(ime_datoteke)
for blok in vzorec_bloka.finditer(vsebina):
yield izloci_podatke_filma(blok.group(0))
def izloci_podatke_rezultati(imenik):
'''Poišče ujemanja med regexom rezultatov in datotekami v imeniku in jih vrne v obliki seznama.'''
ujemanja = []
for datoteka in orodja.datoteke(imenik):
print(datoteka)
vsebina = orodja.vsebina_datoteke(datoteka)
for podatki in re.finditer(regex_rezultatov, vsebina):
ujemanja.append(pripravi_podatke_rezultati(podatki))
print(ujemanja)
return ujemanja
def animeji_na_strani(stran):
start = stran * 50
url = (
f'https://myanimelist.net/anime.php?cat=0&q=&type=1&score=0&status=2&p=0&r=0&sm=0&sd=0&sy=0&em=0&ed=0&ey=0&c%5B0%5D=a&c%5B1%5D=b&c%5B2%5D=c&c%5B3%5D=d&c%5B4%5D=e&c%5B5%5D=f&c%5B6%5D=g&gx=1&genre%5B0%5D=9&genre%5B1%5D=12&genre%5B2%5D=26&genre%5B3%5D=28&genre%5B4%5D=33&genre%5B5%5D=34&o=7&w=1&show={start}'
)
ime_datoteke = f'zajeti-podatki/popularni_animeji_{stran}'
orodja.shrani_spletno_stran(url, ime_datoteke)
vsebina = orodja.vsebina_datoteke(ime_datoteke)
for blok in vzorec_bloka.finditer(vsebina):
yield izloci_podatke_animeja(blok.group(0))
def zajemi_isbn():
regex_isbn=re.compile(
r'gp/product-reviews/(\d{10}).{150,200}?\$\d*\.\d{2} \$(\d*\.\d{2})',
flags=re.S
)
seznamISBN=[]
for html_datoteka in orodja.datoteke('podatki/amazon/'):
for knjiga in re.finditer(regex_isbn, orodja.vsebina_datoteke(html_datoteka)):
seznamISBN.append(knjiga.group(1))
return seznamISBN
def priprava_amazon():
regex_knjige = re.compile(
r'gp/product-reviews/(?P<ISBN10>\d{10}).{150,200}?\$\d*\.\d{2} \$(?P<cenaD>\d*\.\d{2})',
flags=re.S
)
knjige = {}
for html_datoteka in orodja.datoteke('podatki/amazon5/'):
for knjiga in re.finditer(regex_knjige, orodja.vsebina_datoteke(html_datoteka)):
podatki=knjiga.groupdict()
knjige[podatki['ISBN10']]=podatki
orodja.zapisi_tabelo(sorted(knjige.values(), key=lambda knjiga: knjiga['ISBN10']),
['ISBN10','cenaD'], 'csv-datoteke/amazon2.csv')
def zajemi_bwin():
if not os.path.exists(datum):
os.makedirs(datum)
orodja.shrani('https://sports.bwin.com/en/sports', datum + 'bwin.html')
izraz = r'href="(?P<link>/en/sports/(?P<id>[0-9]+)/.*/(?P<sport>.*))" title=".*">\s*<span class="sporticon"'
#print(izraz)
regex_url_filma = re.compile(izraz)
#print(regex_url_filma)
#print(orodja.vsebina_datoteke(datum + 'bwin.html'))
for sport in re.finditer(regex_url_filma, orodja.vsebina_datoteke(datum + 'bwin.html')):
url = 'https://sports.bwin.com{}'.format(sport.group('link'))
ime_datoteke = datum + 'bwin/{}.html'.format(sport.group('sport'))
print(url)
orodja.shrani(url, ime_datoteke)
def priprava_depository():
regex_knjige = re.compile(
r'<meta itemprop="author" content="(?P<avtor>.*?)".*?'
r'<h1 itemprop="name">(?P<naslov>.*?)<.*?'
r'<div class="item-info-wrap">\s*<p class="price">\s*(?P<cenaE>\d*,\d{2}).*?'
r'<label>Format</label>\s*<span>\s*(?P<format>\w*).*?'
r'"numberOfPages">(\d+).*?"datePublished">(?P<datum>\d{2} \w{3} \d{4}).*?'
r'Language</label>\s*<span>\s*(?P<jezik>\w*).*?'
r'ISBN10</label>\s*<span>(?P<ISBN10>\d{10}).*?'
r'ISBN13</label>\s*<span itemprop="isbn">(?P<ISBN13>\d{13})',
flags=re.S
)
knjige = {}
for html_datoteka in orodja.datoteke('podatki/depositoryISBN/'):
for knjiga in re.finditer(regex_knjige, orodja.vsebina_datoteke(html_datoteka)):
podatki=knjiga.groupdict()
knjige[podatki['ISBN10']]=podatki
orodja.zapisi_tabelo(sorted(knjige.values(), key=lambda knjiga: knjiga['ISBN10']),
['ISBN10','avtor', 'naslov', 'cenaE', 'format','jezik','datum','ISBN13'],
'csv-datoteke/depository2.csv')
def zajemi_url():
global tekme
orodja.shrani('http://www.fis-ski.com/alpine-skiing/athletes/', 'zajete-strani/sportniki.html')
#print("Zajemam ulr ... ")
url = re.compile(
r'<a href=..alpine-skiing.athletes\D+(?P<id>\d+).. alt=.(?P<ime>[\w| |-]+)'
)
smucarji = []
for vnos in re.finditer(url, orodja.vsebina_datoteke('zajete-strani/sportniki.html')):
st='{}'.format(vnos.group('id'))
ime='{}'.format(vnos.group('ime'))
#print (ime, st)
#print ('1')
smucarji.append({'id': st, 'ime': ime})
tekme=[]
grange(st, ime) #zajame podatke za posameznega smučarja
#orodja.zapisi_tabelo(smucarji,['id', 'ime'], 'csv-datoteke/smucarji.csv')
orodja.zapisi_tabelo(tekmovalci, ['id', 'ime', 'drzava', 'smuci'], 'csv-datoteke/smucarji.csv')
def izloci_podatke_filmov(imenik):
filmi = []
for html_datoteka in orodja.datoteke(imenik):
for film in re.finditer(regex_filma, orodja.vsebina_datoteke(html_datoteka)):
filmi.append(pocisti_film(film))
return filmi
def pripravi_bwin(potdatoteke = datum):
regex_celatabela = re.compile(
r'(?P<vse>.*<a class="league-link" href=".*" >(?P<ime_dogodka>.*.)\n *- (?P<drzava>.*)</a>'
r'[^я]*?<span class="option-name">(?P<igralec>.*)</span>\n *<span class="odds">(?P<kvota>.*)</span>'
r'[^я]*?(<a class="league-link" href=|<div class="ui-widget-content" id="sport-footer">))'
)
regex_celatabela1 = re.compile(
r'(?P<vse>.*<a class="league-link" href=".*" >(?P<ime_dogodka>.*.)\n *- (?P<drzava>.*)</a>'
r'[^я]*?<span class="option-name">(?P<igralec>.*)</span>\n *<span class="odds">(?P<kvota>.*)</span>'
r'[^я]*?(<a class="league-link" href=|<div class="ui-widget-content" id="sport-footer">))'
)
regex_dogodka1 = re.compile(
r'.*<h6 class="game">(?P<dogodek>.*)</h6>'
r'[^я]<h6 class="game">'
#r'.*<a class="league-link" href=".*" >(?P<dogodek>.*.\n.*)</a>'
)
regex_dogodka1 = re.compile(
r'.*<a class="league-link" href=".*" >(?P<dogodek>.*.)\n* *- (?P<drzava>.*)</a>'
r''
#r'.*<a class="league-link" href=".*" >(?P<dogodek>.*.\n.*)</a>'
)
regex_sporta = re.compile(
r'<button type="submit" class="no-uniform option-button fav-button">\n* *<span class="option-name">'
r'(?P<ime>.*)</span>\n* *<span class="odds">(?P<kvota>.*)</span>')
dogodek, igralec = {}, {}
drzava, kvota = set(), []
podatki_dogodkov = {}
j = 1
i = 1
kvot = 0
print(orodja.datoteke(potdatoteke + '/bwin/'))
for html_datoteka in orodja.datoteke(potdatoteke + '/bwin/'):
#print(orodja.vsebina_datoteke(html_datoteka))
for tabela in re.finditer(regex_celatabela, orodja.vsebina_datoteke(html_datoteka)):
print('***')
#print(tabela)
for podatki in re.finditer(regex_celatabela, tabela.group('vse')):
#for dogodek in re.finditer(regex_dogodka, tabela.group('vse')):
#dogodek = podatki.group('dogodek')
dogodek = tabela.group('ime_dogodka')
igralec = tabela.group('igralec')
print(dogodek)
print(podatki)
print(igralec + tabela.group('kvota'))
podatki_dogodka = podatki_dogodkov.get(dogodek, {})
podatki_dogodka[tabela.group('igralec')] = tabela.group('kvota')
podatki_dogodkov[dogodek] = podatki_dogodka
#drzava.add(podatki.group('drzava'))
#print(podatki.group('dogodek') + ' -- ' + podatki.group('igralec') + ' -- ' + podatki.group('kvota'))
#for html_datoteka in orodja.datoteke(potdatoteke + '/bwin/'):
# print(html_datoteka)
# for ime in re.finditer(regex_dogodka, orodja.vsebina_datoteke(html_datoteka)):
# if ime.group('drzava') == 'Slovenia':
# pass
#print(ime.group('dogodek') + ' ' + ime.group('drzava') + ' ' + html_datoteka)
# j += 1
for html_datoteka in orodja.datoteke(potdatoteke + '/bwin/'):
for ime in re.finditer(regex_sporta, orodja.vsebina_datoteke(html_datoteka)):
#print(ime.group('ime') + ' ' + ime.group('kvota') + ' ' + datum[14:-1])
i += 1
kvot += float(ime.group('kvota'))
orodja.zapisi_tabelo(igralec.values(), ['igralec', 'kvota'], 'csv-datoteke/dogodki.csv')
print(drzava)
print(igralec)
return (i, j, kvot/i)
vzorec_tekmovalca = re.compile(r'<td class=.i\d. align=.right.> (?P<uvrstitev>([12]?\d)|(30))</td>\s'\
r'<td .*?</td>\s'\
r'<td class=.i\d. align=.right.> (?P<id_tekmovalca>\d+?)</td>\s'\
r'<td class=.i\d.><a href=".*?">(?P<ime>.*?)</a> </td>\s'\
r'<td class=.*?>(?P<letnica>\d+?) </td>\s'\
r'<td class=.*?>(?P<nacionalnost>\w+?) </td>\s'\
r'<td class=.*?> (?P<dolzina1>.*?)</td>\s'\
r'<td .*?</td>\s<td class=.*?> (?P<dolzina2>.*?)</td>\s'\
r'<td .*?</td>\s<td class=.*?> (?P<tocke>.*?)</td>')
tekmovalci, prizorisca = {}, {}
uvrstitve, tekmovanja = [], []
for tekma in tekme:
for opis in re.finditer(vzorec_tekme, orodja.vsebina_datoteke(tekma)): # na vsaki strani bo le eno ujemanje
ta_tekma = re.findall(idtekme, orodja.vsebina_datoteke(tekma))[0]
podatki_tekma = opis.groupdict()
podatki_tekma['id_tekme']= (ta_tekma)
podatki_tekma['id_prizorisca'] = podatki_tekma['id_prizorisca'][:5]
podatki_tekma['sezona'] = tekma.split(sep = '_')[1][0:4]
ime_prizorisca = podatki_tekma.pop('prizorisce')
drzava_prizorisca = podatki_tekma.pop('drzava')
prizorisca[podatki_tekma['id_prizorisca']] = {'id_prizorisca' : podatki_tekma['id_prizorisca'],
'kraj' : ime_prizorisca,
'država': drzava_prizorisca
}
tekmovanja += [podatki_tekma]
for tekmovalec in re.finditer(vzorec_tekmovalca, orodja.vsebina_datoteke(tekma)):
import re
import orodja
reg_datumi = re.compile(r'<h2 class="event-group-level3">[^Я]*? *.* - (?P<datum>.*)[^Я]*?<div class="ui-widget-content-body')
reg_dogodka = re.compile(r'.*<a class="league-link" href=".*" >(?P<dogodek>.*.)\n* *- (?P<drzava>.*)</a>')
#<h2 class="event-group-level3">[^Я]*? *.* - (?P<datum>.*)[^Я]*?(<a class="league-link" href=|<div class="ui-widget-content" id="sport-footer">)
for ujemanje in re.finditer(reg_datumi, orodja.vsebina_datoteke('zajete-strani/2016-01-16/bwin/alpine-skiing.html')):
print(ujemanje.groupdict())
