def poisci_kljucne_besede(seznam_vseh_knjig):
for knjiga in seznam_vseh_knjig:
if knjiga['opis'] is not None:
opis = knjiga['opis'].lower()
naslov = knjiga['naslov'].lower()
slovar_kljucnih = naredi_slovar_kljucnih_besed()
for beseda in slovar_kljucnih.keys():
if beseda in opis + naslov:
kljucna_beseda = dict()
kljucna_beseda['id_knjige'] = knjiga['id']
kljucna_beseda['kljucna_beseda'] = slovar_kljucnih[beseda]
seznam_vseh_knjig_kljucnih_besed.append(kljucna_beseda)
dodane_knjige.add(knjiga['id'])
frekvenca[slovar_kljucnih[beseda]] += 1
if knjiga[
'id'] not in dodane_knjige: # Naredi csv knjig, ki niso imele nobene kljucne besede
mankajoce.append(knjiga)
orodja.zapisi_tabelo(mankajoce, [
'id', 'ISBN', 'naslov', 'dolzina', 'povprecna_ocena', 'stevilo_ocen',
'leto', 'opis', 'url_naslovnice'
], 'podatki/mankajoce.csv')
print(len(dodane_knjige), len(seznam_vseh_knjig_kljucnih_besed))
print(sorted(frekvenca, key=frekvenca.get,
reverse=True)) # Vrne seznam od najpogostejše do neobstojece
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 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_slike():
'''
Funkcija shrani slike in naredi csv datoteko s podatki o geografski sirin in visini.
'''
for krat, dat in slovar_drzav.items():
if dat in {
'Unified_Team_Ex_Ussr_In_1992',
'_Independent_Olympic_Athletes', 'Bohemia_Tch_Since_1920',
'British_West_Indies_Bar_Jam',
'Independant Olympic Participant', 'Refugee Olympic Team',
'International Olympic Committee',
'Independent Olympic Athletes'
}:
continue
datoteka = "{}.html".format(dat)
pot = os.path.join("drzave", datoteka)
pot_slike = os.path.join("slike", "{}.png".format(krat))
podatki = dobi_tabelo_slike_in_koordinate(pot)
pod = podatki.get(krat)
if pod:
naslov = pod[0]
slika = 'https:{}.png'.format(naslov[:-8])
urllib.request.urlretrieve(slika, pot_slike)
orodja.zapisi_tabelo(
koordinate, ['kratica_drzave', 'geo_visina', 'geo_sirina'],
'koordinate.csv')
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 csv_vina():
'''Podatke vin zapiše v csv datoteko'''
vina = izloci_podatke_vin('vina', regex_vino)
wines = []
for vino in vina:
ime = vino['Name']
barva = vino['Color']
cena = vino['Price']
stopnja_alkohola = vino['ABV']
drzava = vino['Country']
regija = vino['Region']
# TODO: filter the descriptions for nonsense!
opis = vino['Description']
okus = vino['Taste']
vonj = vino['Smell']
slika = vino['Image']
# velikost:
velikost = ""
if "mL" in str(vino['Size']):
for sign in str(vino['Size']):
if sign not in " mL":
velikost += sign
velikost = float(velikost) / 1000
else:
for sign in str(vino['Size']):
if sign != "l":
velikost += sign
velikost = float(velikost)
# vrsta:
# parsing the strings
sorts = vino['Varietal']
if len(sorts) == 1:
vrsta = sorts[0]
else:
vrsta = 'blend'
# write a dictionary for each wine
entry = {
'ime': ime,
'vrsta': vrsta,
'barva': barva,
'velikost': velikost,
'stopnja_alkohola': stopnja_alkohola,
'drzava': drzava,
'regija': regija,
'cena': cena,
'okus': okus,
'vonj': vonj,
'opis': opis,
'slika': slika
}
wines.append(entry)
column_names = wines[0].keys()
orodja.zapisi_tabelo(wines, column_names, 'wines.csv')
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 pripravi_nba():
regex_nba = re.compile(
r'<a href="http://www.espn.com/nba/player/_/id/(?P<id>\d+)/.*?>(?P<igralec>.*?)</a>.*?align="left">(?P<ekipa>.*?)</td><td >(?P<odigrane_igre>\d+)</td><td >(?P<minute_natekmo>.*?)<.*?class="sortcell">(?P<točke_na_tekmo>.*?)<.*?/td><td >.(?P<met_iz_igre>\d+)<.*?</td><td >.(?P<trojke>\d+)<.*?</td><td >.(?P<prosti_meti>\d+)<.*?>',
flags=re.DOTALL)
#<a href="http://www.espn.com/nba/player/_/id/6583/anthony-davis">Anthony Davis</a>, PF</td><td align="left">NO</td><td >37</td><td >37.1</td><td class="sortcell">29.1</td><td >10.5-21.2</td><td >.496</td><td >0.6-1.9</td><td >.300</td><td >7.6-9.5</td><td >.796</td></tr><tr class="evenrow player-46-3992" align="right"><td align="left">3</td><td align="left">
pojavitve = []
for html_datoteka in orodja.datoteke('StatLeaders1617/'):
vsebina = orodja.vsebina_datoteke(html_datoteka)
for pojavitev in re.finditer(regex_nba, vsebina):
pojavitve.append(zbrisi_pojavitev(pojavitev))
orodja.zapisi_tabelo(pojavitve, [
'id', 'igralec', 'ekipa', 'odigrane_igre', 'minute_natekmo',
'točke_na_tekmo', 'met_iz_igre', 'trojke', 'prosti_meti'
], 'pojavitve7.csv')
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 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')
return filmi
def razdeli_tabelo(filmi):
osebe, vloge, zanri = [], [], []
videne_osebe = set()
for film in filmi:
for zanr in film.pop('zanri'):
zanri.append({'film': film['id'], 'zanr': zanr})
for reziser in film.pop('reziserji'):
if reziser['id'] not in videne_osebe:
videne_osebe.add(reziser['id'])
osebe.append(reziser)
vloge.append({'film': film['id'], 'oseba': reziser['id'], 'vloga': 'reziser'})
for igralec in film.pop('igralci'):
if igralec['id'] not in videne_osebe:
videne_osebe.add(igralec['id'])
osebe.append(igralec)
vloge.append({'film': film['id'], 'oseba': igralec['id'], 'vloga': 'igralec'})
return filmi, osebe, vloge, zanri
filmi = izloci_podatke_filmov('../../ap-1-zajem-podatkov/predavanja/imdb/')
filmi, osebe, vloge, zanri = razdeli_tabelo(filmi)
orodja.zapisi_tabelo(filmi, ['id', 'naslov', 'leto', 'dolzina', 'ocena', 'opis'], 'filmi.csv')
orodja.zapisi_tabelo(osebe, ['id', 'ime'], 'osebe.csv')
orodja.zapisi_tabelo(vloge, ['film', 'oseba', 'vloga'], 'vloge.csv')
orodja.zapisi_tabelo(zanri, ['film', 'zanr'], 'zanri.csv')
mapa_zanri = orodja.datoteke("zanri")
dcz.shrani_zanre(mapa_zanri)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Tukaj zajamemo podatke za tabelo žanrov
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
dckb.poisci_kljucne_besede(dc.seznam_vseh_knjig)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Tukaj zajamemo podatke za tabelo knjiga_kljucna_beseda
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
print('delam csvje')
# naredimo csv datoteke iz zbranih podatkov:
# KNJIGA
orodja.zapisi_tabelo(dc.seznam_vseh_knjig, [
'id', 'ISBN', 'naslov', 'dolzina', 'povprecna_ocena', 'stevilo_ocen',
'leto', 'opis', 'url_naslovnice'
], 'podatki/knjiga.csv')
# AVTOR
orodja.zapisi_tabelo(
dca.seznam_vseh_avtorjev,
['id', 'ime', 'povprecna_ocena', 'datum_rojstva', 'kraj_rojstva'],
'podatki/avtor.csv')
# SERIJA
orodja.zapisi_tabelo(nov_seznam_serij, ['id', 'ime', 'stevilo_knjig'],
'podatki/serija.csv')
# ŽANR (drugi poskus)
orodja.zapisi_tabelo(dcz.seznam_vseh_zanrov, ['ime_zanra', 'opis'],
'podatki/zanr.csv')
# knjiga-avtor:
podatki['mesec'] = int(podatki['mesec'])
podatki['dan'] = int(podatki['dan'])
podatki['drzava'] = podatki['drzava'].strip()
podatki['ura'] = podatki['ura'].strip()
podatki['sirina'] = float(podatki['sirina'])
podatki['dolzina'] = float(podatki['dolzina'])
podatki['globina'] = int(podatki['globina'])
podatki['magnituda'] = float(podatki['magnituda'])
return podatki
def izloci_podatke_potresov(potres):
regex_potresa = re.compile(
r'<a href=".+?\.php\?id=(?P<id>\d{6})">(?P<leto>\d{4})-(?P<mesec>\d{2})-(?P<dan>\d{2}).+?(?P<ura>\d{2}:\d{2}:\d{1,2})\.\d</a>.+?'
r'<td class="tabev1">(?P<sirina>\d{1,2}\.\d{1,2}) </td><td class="tabev2">[NS].+?'
r'<td class="tabev1">(?P<dolzina>\d{1,2}\.\d{1,2}) </td><td class="tabev2">[EW].+?'
r'<td class=\"tabev\d\">(?P<globina>\d{1,3})<\/td>.+?'
r'<td class=\"tabev\d\">(?P<magnituda>\d\.\d)<\/td>.?'
r'<td id=\"reg\d+\" class=\"tb_region\" > (?P<drzava>.+?)<\/td>'
, flags=re.DOTALL)
potresi = []
for html_datoteka in orodja.datoteke('strani/'):
for potres in re.finditer(regex_potresa, orodja.vsebina_datoteke(html_datoteka)):
potresi.append(pocisti_potres(potres))
#print(potres.group('id'), potres.group('sirina'), potres.group('magnituda'))
return potresi
#izloci_podatke_potresov()
potresi = izloci_podatke_potresov('../../projectT/')
orodja.zapisi_tabelo(potresi, ['id', 'leto', 'mesec', 'dan', 'ura', 'drzava', 'sirina', 'dolzina', 'globina', 'magnituda'], 'potresi.csv')
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)
}
tekmovanja += [podatki_tekma]
for tekmovalec in re.finditer(vzorec_tekmovalca, orodja.vsebina_datoteke(tekma)):
mesto = tekmovalec.groupdict()
id_cloveka = mesto['id_tekmovalca']
ime_cloveka = mesto.pop('ime')
letnica_cloveka = mesto.pop('letnica')
nacionalnost_cloveka = mesto.pop('nacionalnost')
tekmovalci[id_cloveka] = {'id_tekmovalca' : id_cloveka,
'ime' : uredi_ime(ime_cloveka),
'nacionalnost' : nacionalnost_cloveka
'letnica' : letnica_cloveka
}
mesto['id_tekme'] = ta_tekma
uvrstitve += [mesto]
idji_tek = list(tekmovalci)
seznam_slovarjev_tekmovalcev =[tekmovalci[idjek] for idjek in idji_tek]
idji_priz = list(prizorisca)
seznam_slovarjev_prizorisc =[prizorisca[idjek] for idjek in idji_priz]
orodja.zapisi_tabelo(seznam_slovarjev_tekmovalcev, ['id_tekmovalca', 'ime', 'nacionalnost', 'letnica'], 'podatki/csv_tekmovalci.csv')
orodja.zapisi_tabelo(uvrstitve,['id_tekme', 'id_tekmovalca', 'uvrstitev', 'dolzina1', 'dolzina2', 'tocke'], 'podatki/csv_uvrstitve.csv')
orodja.zapisi_tabelo(tekmovanja,['id_tekme', 'id_prizorisca', 'datum', 'sezona'], 'podatki/csv_tekmovanja.csv')
orodja.zapisi_tabelo(seznam_slovarjev_prizorisc, ['id_prizorisca', 'kraj', 'država'], 'podatki/csv_prizorisca.csv')
def csv_piva():
piva = izloci_podatke_piv('beer', regex_pivo)
beers = []
country_dic = {
'Scotch Beer': 'Scotland',
'English Beer': 'England',
'Belgian Beer': 'Belgium',
'American Beer': 'United States',
'Japanese Beer': 'Japan',
'Dutch Beer': 'Netherlands',
'Danish Beer': 'Denmark',
'Kiwi Beer': 'New Zealand',
'Australian Beer': 'Australia',
'German Beer': 'Germany',
'Icelandic Beer': 'Iceland'
}
for pivo in piva:
ime = pivo['Name']
pivovarna = pivo['Brewery']
opis = pivo['Description']
drzava = country_dic[pivo['Country']]
slika = pivo['Image']
# velikost:
velikost = ""
for sign in str(pivo['Volume']):
if sign not in "cl":
velikost += sign
velikost = float(velikost) / 100
# stopnja_alkohola:
stopnja_alkohola = ""
for sign in str(pivo['ABV']):
if sign == ',':
stopnja_alkohola += '.'
else:
stopnja_alkohola += sign
stopnja_alkohola = float(stopnja_alkohola)
# cena:
if pivo['Price'] == 'Discontinued':
cena = None
else:
cena = pivo['Price']
# vrsta:
# some types are doubled, we need to join them together
if pivo['Style'] == 'Cask Aged Beer':
vrsta = 'Cask-Aged Beer'
elif pivo['Style'] == 'Spiced Beer':
vrsta = 'Herb / Spice Beer'
elif pivo['Style'] == 'Spiced Beer':
vrsta = 'Herb / Spice Beer'
elif pivo['Style'] == 'Wheat Beer':
vrsta = 'Wheat / Wit / White Beer'
else:
vrsta = pivo['Style']
# write a dictionary for each beer
entry = {
'ime': ime,
'pivovarna': pivovarna,
'vrsta': vrsta,
'velikost': velikost,
'stopnja_alkohola': stopnja_alkohola,
'drzava': drzava,
'cena': cena,
'opis': opis,
'slika': slika
}
beers.append(entry)
column_names = [
'ime', 'pivovarna', 'vrsta', 'velikost', 'stopnja_alkohola', 'drzava',
'cena', 'opis', 'slika'
]
# write a new file with the adjusted data
orodja.zapisi_tabelo(beers, column_names, 'beers.csv')
})
del recept['kategorija']
del recept['podkategorija']
else:
kategorije.append({
'recept': recept['id'],
'kategorija': recept['kategorija']
})
del recept['kategorija']
del recept['podkategorija']
avtor = recept['avtor']
if avtor['id'] not in viden_avtor:
viden_avtor.append(avtor['id'])
avtorji.append(avtor)
povezave.append({'recept': recept['id'], 'avtor': avtor['id']})
del recept['avtor']
return recepti, avtorji, kategorije, povezave
recepti = izloci_podatke_receptov('ReceptiHTML/')
recepti, avtorji, kategorije, povezave = razdeli_tabelo(recepti)
orodja.zapisi_tabelo(recepti, [
'id', 'naslov', 'objava', 'letoobjave', 'zahtevnost', 'priprava',
'kolicina', 'stmnenj', 'stfoto', 'zadnjafoto', 'letofoto', 'zdravajed'
], 'ReceptiCSV/recepti.csv')
orodja.zapisi_tabelo(avtorji, ['id', 'avtor', 'spol'],
'ReceptiCSV/avtorji.csv')
orodja.zapisi_tabelo(povezave, ['recept', 'avtor'], 'ReceptiCSV/povezave.csv')
orodja.zapisi_tabelo(kategorije, ['recept', 'kategorija', 'podkategorija'],
'ReceptiCSV/kategorije.csv')
print("Končano!")
#zajemi_flisar()
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')
zajemi_url()
orodja.zapisi_tabelo(vse, ['id','datum', 'kraj', 'disciplina', 'mesto'], 'csv-datoteke/vse.csv')
for tek in tekma:
if tek['id_tekmovalca'] not in tekmovalci_id:
tekmovalci_id.add(tek['id_tekmovalca'])
podatki_tekmovalec.append({
'id_tekmovalca': tek['id_tekmovalca'],
'tekmovalec': tek['tekmovalec'],
'leto_rojstva': tek['leto_rojstva'],
'drzava': tek['drzava']
})
for tek in tekma:
podatki_uvrstitve.append({
'mesto': tek['mesto'],
'id_tekmovalca': tek['id_tekmovalca'],
'tocke': tek['tocke']
})
return podatki_tekmovalec, podatki_uvrstitve
tekme = izloci_podatke_tekma('smucarskiskoki/tekme_id/')
rezultati = izloci_podatke_rezultati('smucarskiskoki/tekme_id/')
tekmovalci, uvrstitve = izloci_tekmovalce(rezultati)
orodja.zapisi_tabelo(
tekme, ['prizorisce', 'drzava_prizorisca', 'datum', 'velikost_skakalnice'],
'smucarskiskoki/tekme.csv')
orodja.zapisi_tabelo(uvrstitve, ['mesto', 'id_tekmovalca', 'tocke'],
'smucarskiskoki/rezultati.csv')
orodja.zapisi_tabelo(tekmovalci,
['id_tekmovalca', 'tekmovalec', 'leto_rojstva', 'drzava'],
'smucarskiskoki/tekmovalci.csv')
regex_skupno = re.compile(
r'<option value="/results.php\?s=80&y=(?P<Leto>\d{4})&c=1" selected>.*?'
r'<td align="center">1</td><td align="left"><a target="_blank" href="http://forix.autosport.com/forix.php\?series=80&driver=\d{10}">(?P<Prvak>.*?)</a></td><td align="right">.*'
r'<td align="center">2</td><td align="left"><a target="_blank" href="http://forix.autosport.com/forix.php\?series=80&driver=\d{10}">(?P<Podprvak>.*?)</a></td><td align="right">.*'
r'<tr bgcolor="#FFFFFF"><td align="center">1</td><td align="left">(?P<Prvi_proizvajalec>.*?)</td><td align="right">.*'
r'<tr bgcolor="#FFFFFF"><td align="center">2</td><td align="left">(?P<Drugi_proizvajalec>.*?)</td><td align="right">.*',
flags=re.DOTALL
)
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
#zajemi_rezultate()
#izbrisi_neobstojece()
rezultati_dirk = izloci_rezultate('rezultati/', regex_rezultati)
skupni_rezultati = izloci_rezultate('skupni_rezultati/', regex_skupno)
orodja.zapisi_tabelo(rezultati_dirk, ['Leto', 'Dirka', 'Zmagovalec', 'Mostvo_zmagovalca', 'Drugi', 'Mostvo_drugega', 'Tretji', 'Mostvo_tretjega'], 'csv-datoteke/rezultati_dirk.csv')
orodja.zapisi_tabelo(skupni_rezultati, ['Leto', 'Prvak', 'Podprvak', 'Prvi_proizvajalec', 'Drugi_proizvajalec'], 'csv-datoteke/skupni_rezultati.csv')
r'>(?P<naslov>.*?)</a>.*?'
r'lister-item-year text-muted unbold">.*?\((?P<leto>\d{4})\)</span>.*?'
r'runtime">(?P<dolzina>.*?) min</.*?'
r'<strong>(?P<ocena>.+?)</strong>.*?'
r'<p class="text-muted">(?P<opis>.+?)<.*?'
r'Directors?:.*?<a href=.*?>(?P<reziser>.+?)</a>.*?',
flags=re.DOTALL
)
def pocisti_film(film):
podatki = film.groupdict()
podatki['id'] = int(podatki['id'])
podatki['dolzina'] = int(podatki['dolzina'])
podatki['leto'] = int(podatki['leto'])
podatki['opis'] = podatki['opis'].strip()
podatki['ocena'] = float(podatki['ocena'])
return podatki
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
filmi = izloci_podatke_filmov('../../ap-1-zajem-podatkov/predavanja/imdb/')
orodja.zapisi_tabelo(filmi, ['id', 'naslov', 'leto', 'reziser', 'dolzina', 'ocena', 'opis'], 'filmi.csv')
for datoteka in orodja.datoteke('strani_projektov/'):
for ujemanje in re.finditer(r'window\.current_project(?P<iskanje>.*?)www\.kickstarter\.com/discover/categories',orodja.vsebina_datoteke(datoteka)):
iskalni_niz = ujemanje.groupdict()['iskanje']
for projekt in re.finditer(regex,iskalni_niz):
projekti.append(projekt.groupdict())
def pocisti_str(besedilo):
besedilo = besedilo.replace(r''','\'')
besedilo = besedilo.replace(r'&','&')
besedilo = besedilo.replace('\\\\n','')
return(besedilo)
for projekt in projekti:
projekt['cilj'] = int(projekt['cilj'])
projekt['pridobljen_denar'] = int(projekt['pridobljen_denar'])
projekt['st_backerjev'] = int(projekt['st_backerjev'])
projekt['kategorija'] = pocisti_str(projekt['kategorija'])
projekt['naslov'] = pocisti_str(projekt['naslov'])
projekt['povzetek'] = pocisti_str(projekt['povzetek'])
projekt['avtor'] = pocisti_str(projekt['avtor'])
if projekt['pridobljen_denar'] < projekt['cilj']:
projekt['uspesnost'] = 0
else:
projekt['uspesnost'] = 1
orodja.zapisi_tabelo(projekti,['naslov','avtor','drzava','kategorija','st_backerjev','cilj','pridobljen_denar','uspesnost','povzetek'],'projekti.csv')
r'<tr><th>Developer:</th><td><a itemprop="author" href=".*?;hl=en">(?P<proizvajalec>.+?)</a></td></tr>.*?'
r'<tr><th>Category:</th><td><a href=".*?;hl=en" itemprop="applicationCategory">(?P<kategorija>.+?)</a></td></tr>.*?'
r'<tr><th>Price:</th><td>(?P<cena>.+?)</td></tr>.*?'
r'<tr><th>Total ratings:</th><td itemprop="ratingCount">(?P<stevilo_ocen>.+?)</td></tr>.*?'
r'<tr><th>Average rating:</th><td itemprop="ratingValue">(?P<ocena>.+?)</td></tr>.*?',
flags=re.DOTALL)
def pocisti_aplikacijo(aplikacija):
podatki = aplikacija.groupdict()
podatki['ocena'] = float(podatki['ocena'])
podatki['prenosi'] = int(podatki['prenosi'].replace(',', ''))
podatki['stevilo_ocen'] = int(podatki['stevilo_ocen'].replace(',', ''))
return podatki
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
aplikacije = izloci_podatke_aplikacij('app/')
orodja.zapisi_tabelo(aplikacije, [
'ime', 'proizvajalec', 'kategorija', 'cena', 'stevilo_ocen', 'ocena',
'prenosi'
], 'aplikacije.csv')
r';(?P<regija>(.*?))</.*?',
flags=re.DOTALL)
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
potresi = izloci_podatke('Potresi/')
orodja.zapisi_tabelo(potresi, [
'id', 'leto', 'mesec', 'dan', 'ura', 'minuta', 'sekunda', 'DOL', 'dolzina',
'SIR', 'sirina', 'globina', 'magnituda', 'regija'
], 'potresi_potresi.csv')
# =================== K O N E C D O K U M E N T A ============================
# =============== samo še neke stvari od prej so spodaj ========================
# regex_potresa = re.compile(
# r'<tr id="(?P<id>(\d{6}))".*?'
# r'>(?P<leto>(\d{4}))-(?P<mesec>(\d{2}))-(?P<dan>(\d{2})).*?'
# r';(?P<ura>(\d{2})):(?P<minuta>(\d{2})):(?P<sekunda>(\d{2}.\d))<.*?'
# r'>(?P<sirina>(\d{2}.\d{2}))&.*?'
# r'">(?P<SIR>([NS]))&.*?'
# r'>(?P<dolzina>(\d{2}.\d{2}))&.*?'
# r'">(?P<DOL>([WE]))&.*?'
# r'">(?P<globina>(\d+))<.*?'
# r'">(?P<magnituda>(\d.\d))</.*?'
#vzeto iz predavanj
#v interesih transparence bom povedal, da je bila html datoteka samo ena in priredil sem jo, da bi regex deloval
regex_kategorije = re.compile(
r'<li><a href="http://www.ebay.com/sch/(?P<html_ime>\D+?.*?)/(?P<id>\d+)/i.html" class="ch">(?P<ime>.*?)</a></li>',
flags=re.DOTALL)
def pocisti_kategorije(kategorija):
podatki = kategorija.groupdict()
podatki['id'] = int(podatki['id'])
podatki['html_ime'] = (podatki['html_ime'])
podatki['ime'] = (podatki['ime'])
return podatki
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
kategorije = izloci_podatke_kategorij('Data/Kategorije/')
orodja.zapisi_tabelo(kategorije, ['id', 'html_ime', 'ime'],
'Data/Kategorije/kategorije.csv')
r'''itemprop="datePublished">\d\d (?P<mesec_izdaje>\D\D\D) (?P<leto_izdaje>\d\d\d\d)<\/p>'''
r'''.*?'''
r'''<p class="format">(?P<format>.*?)<\/p>'''
,flags=re.DOTALL)
def izloci_podatke_knjig(imenik):
knjige = []
for html_datoteka in orodja.datoteke(imenik):
for knjiga in re.finditer(regex_knjige, orodja.vsebina_datoteke(html_datoteka)):
knjige.append(pocisti_knjige(knjiga))
return knjige
def pocisti_knjige(knjiga):
podatki = knjiga.groupdict()
podatki['uvrstitev'] = int(podatki['uvrstitev'])
podatki['naslov'] = str(podatki['naslov'])
podatki['avtor'] = str(podatki['avtor'])
podatki['mesec_izdaje'] = str(podatki['mesec_izdaje'])
podatki['leto_izdaje'] = int(podatki['leto_izdaje'])
podatki['format'] = str(podatki['format'])
return podatki
def zamenjaj(niz):
niz = niz.replace(''',"'")
return niz
podatki = izloci_podatke_knjig('knjigehtml/')
orodja.zapisi_tabelo(podatki, ['uvrstitev', 'avtor', 'naslov', 'mesec_izdaje', 'leto_izdaje', 'format'], 'KnjigeCSV/podatki.csv')
r'data-stat="age" >(?P<starost>\d{2}-\d{3})<.*?'
r'data-stat="opp_id" ><a href="/teams/(?P<nasprotnik>\D{3})/\d{4}.html">.*?'
r'data-stat="goals" >(?P<zadetki>\d+)<.*?'
r'data-stat="assists" >(?P<asistence>\d+)<.*?'
r'data-stat="points" >(?P<tocke>\d+)<.*?'
r'data-stat="plus_minus" >(?P<plus_minus>-?\d+)<.*?'
r'data-stat="pen_min" >(?P<kazni>\d+)<.*?'
r'data-stat="shots" >(?P<streli>\d+)<.*?'
,
flags=re.DOTALL)
sez = []
sezone = list(range(1991,2005)) + list(range(2006,2009)) + list(range(2012,2018))
for i in sezone:
ime_datoteke = "Jagr{}-{}.html".format("%02d" %((i-1)%100), "%02d" % (i%100))
print(ime_datoteke)
with open(ime_datoteke) as f:
iterator = re.finditer(pattern, f.read())
for tekma in iterator:
sez.append(tekma.groupdict())
orodja.zapisi_tabelo(sez,['st_tekme','starost','nasprotnik','zadetki','asistence','tocke','plus_minus','kazni','streli'],'jagr.csv')
print("Končano!")
import orodja
sahist_regex = re.compile(
r'<tr bgcolor=#.*?><td width=10> (?P<rank>\d+)</a></td><td> '
r'(?P<ime>.*?)</td><td> g</td><td> '
r'(?P<drzava>\w{3})</td><td> '
r'(?P<rating>\d{4})</td><td> \d*?</td><td> '
r'(?P<letnik>\d{4})</td></tr>'
, flags=re.DOTALL)
def pocisti_sahisti(sahisti):
infos = sahisti.groupdict()
infos['rank'] = int(infos['rank'])
infos['ime'] = infos['ime'].strip()
infos['drzava'] = infos['drzava'].strip()
infos['rating'] = int(infos['rating'])
infos['letnik'] = int(infos['letnik'])
return infos
def naredi_csv_datoteke():
sahisti = []
for html_datoteka in orodja.datoteke('lista/'):
for sahist in re.finditer(sahist_regex, orodja.vsebina_datoteke(html_datoteka)):
sahisti.append(pocisti_sahisti(sahist))
return sahisti
sahisti = naredi_csv_datoteke()
orodja.zapisi_tabelo(sahisti, ['rank', 'ime', 'drzava', 'rating', 'letnik'], 'sahisti.csv')
