TECHS5 2017

harjoitukset.py

# Harjoitus 1
a = 16384
b = 32768
c = a + b
print(c)


# Harjoitus 2
a = 25432 + 2321
b = 524288 / 64
c = 4096 % 3
d = b + c
a = d
print(a)

# Kyselyvekotin

# Kysy käyttäjän nimi
nimi = input("Mikä on sinun nimesi? ")
# Kysy käyttäjän ikää
ika = input("Kuinka vanha olet? ")
# Kysy käyttäjän kotikaupunkia
kaupunki = input("Mistä olet kotoisin? ")
# Luo tulostettava viesti
viesti = "Hei {}! Olet {}-vuotias ja kotikaupunkisi on {}.”
tuloste = viesti.format(nimi, ika, kaupunki)
print (tuloste)

# Harjoitus 3A
alku = "Minun nimeni on Jaana-Petteri ja olen "
ika = 22
loppu = " vuotta vanha"
tuloste = alku + str(ika) + loppu
print (tuloste)

# Harjoitus 3B
nimi = "Jaana-Petteri"
ika = 22
kaupunki = "Kokkola"
viesti = "Minun nimeni on {}. Olen {}-vuotias, kotikaupunkini on {} ja pidän Pythonista yli kaiken"
tuloste = viesti.format(nimi, ika, kaupunki)
print (tuloste)

# Sähköpostileikkuri

# Poimitaan sähköposti
sposti = input("Syötä sähköpostiosoite: ").strip()

# Poimi käyttäjänimi
kayttaja = sposti[:sposti.index("@"):1]

# Poimi verkkotunnus
verkkotunnus = sposti[sposti.index("@") + 1::1]

# Luo viesti
viesti = "Käyttäjänimi on {} ja verkkotunnus on {}"

# Muotoile viesti
viesti = viesti.format(kayttaja, verkkotunnus)

# Tulosta viesti
print(viesti)

# URL-leikkuri
# Poimitaan URL
url = input("Syötä verkko-osoite: ").strip()

# Poimi alkuosaton verkko-osoite
pelkka_osoite = url[url.index("//") + 2::1]

# Luo viesti
viesti = "Verkko-osoite ilman alkuosaa on {}"

# Muotoile viesti
viesti = viesti.format(pelkka_osoite)

# Tulosta viesti
print(viesti)


#########################
#
# Luento 3
#
#########################


# A
lista = ["maitoa", "hammastahnaa", "appelsiinimehua", "salmiakkia", "kahvia"]
print(lista)

# B
lista.sort()
print(lista)

# C
lista.append("kvinoaa")
lista.remove("salmiakkia")
lista.sort()
print (lista)

# D
print (lista[1:4])

# E
uusi = input("Minkä tuotteen haluat lisätä listalle? ").lower().strip()

if uusi not in lista:
  lista.append(uusi)
  print("{} lisättiin listalle".format(uusi))
else:
  print("Listalla on jo {}".format(uusi))
print(lista)

# F
print ("Ostoslistalla on seuraavat tuotteet:")
print (lista)

pois = input("Minkä tuotteen haluat poistaa listalta? ").lower().strip()

if pois in lista:
  lista.remove(pois)
  print("{} poistettiin listalta.".format(pois))
else:
  print("Tuotetta ei löytynyt listalta".format(pois))

print ("Listalla on nyt seuraavat tuotteet:")
print (lista)


# Keinoälyportsari
vipit = ["Jari Sillanpää", "Katri Helena", "Cheek", "Kaija Koo", "Erin", "Jonne Aaron", "Neumann", "Teemu Selänne"]

print ("Hyvää iltaa! Olen Sven Marquardt-bot!")
vieras = input("Kerro nimesi, arvon vieras: ").strip().title()

if vieras in vipit:
    print("Tervetuloa Club Mahamieheen {}!".format(vieras))
    poistu = input("Haluatko poistua VIP-listalta? (k/e): ")strip().lower()
    
    if poistu == "k":
        vipit.remove(vieras)
        print(vipit)
    
else:
    print("Valitettavasti ette ole listalla {}.".format(vieras))
    liity = input("Haluatteko, että teidät lisätään VIP-listalle? k/e: ")strip().lower()

    if liity == "k":
        vipit.append(vieras)
        print(vipit)
    else:
        print("Selvä, tervemenoa muualle")

        
# Keikkalippukauppa

keikat = {"David Hasselhof": {"hinta":20, "liput":3},
          "Vanilla Ice": {"hinta":15, "liput": 10},
          "Nickelback": {"hinta":5, "liput":1000},
          "Rebecca Black": {"hinta":10, "liput":5},
          "Jedward": {"hinta":10, "liput":4}
          }

print ("Lähiaikojen keikkavalikoima:")
print (keikat.keys())
            
valinta = input("Minkä artistin keikalle haluat ostaa lippuja? ").strip().title()

if valinta in keikat:
    lippuja = int(input("Montako lippua haluat ostaa? ").strip())

    if keikat[valinta]["liput"] >= lippuja:
        hinta = keikat[valinta]["liput"] * lippuja
        print ("Liput maksavat yhteensä {} euroa.".format(hinta))
        osto = input("Haluatko ostaa liput? (k/e) ").strip().lower()

        if osto == "k":
            print ("Kiitos ostoksestasi. Nauti keikasta jos voit!")
            keikat[valinta]["liput"] = keikat[valinta]["liput"] - 1
        else:
            print("Se lienee viisas valinta. Tervetuloa uudestaan.")
    else:
        print("Valitettavasti myynnissä ei ole niin montaa lippua. Parempi onni ensi kerralla.")

else:
    print("Kyseinen artisti ei esiinny meillä lähiaikoina.")

    
# Sanakirjat

# Harjoitus A

# Luodaan sanakirja, jossa avaimena on opiskelijan nimi ja arvona arvosana
opiskelijat = {"Jenna-Petteri":4, "Esko-Mörkö": 2, "Toni-Kristiina":3, "Mikko-Annukka":5}

# Tulostetaan sanakirja
print (opiskelijat)


# Harjoitus B
# Luodaan sanakirja, jossa avaimena on opiskelijan nimi ja arvona arvosana
opiskelijat = {"Jenna-Petteri":4, "Esko-Mörkö": 2, "Toni-Kristiina":3, "Mikko-Annukka":5}

# Jotta avaimiksi tallennetut opiskelijoiden nimet saadaan järjestettyä aakkosjärjestykseen,
# täytyy sanakirjasta ensin poimia listaus avaimista keys()-funktion avulla. Tämän jälkeen 
# muunnetaan saatu lista list()-funktiolla listamuotoon ja tallennetaan opiskelijat_aakkoset-muuttujaan
opiskelijat_aakkoset = list(opiskelijat.keys())

# Järjestellään lista sort()-funktion avulla
opiskelijat_aakkoset.sort()

# Tulostetaan lista
print(opiskelijat_aakkoset)


# Harjoitus C

# Luodaan sanakirja, jossa avaimena on opiskelijan nimi ja arvona arvosana, ja tulostetaan sanakirja
opiskelijat = {"Jenna-Petteri":4, "Esko-Mörkö": 2, "Toni-Kristiina":3, "Mikko-Annukka":5}
print (opiskelijat)

# Kysytään käyttäjältä haluaako tämä lisätä vai poistaa opiskelijan
toiminto = input("Haluatko lisätä tai poistaa opiskelijan? L/P: ").strip().lower()

# Jos käyttäjä haluaa lisätä opiskelijan:
if toiminto == "l":
    # poimitaan lisättävän opiskelijan nimi muuttujaan
    nimi = input("Syötä lisättävän opiskelijan nimi: ").strip()
    # poimitaan lisättävän opiskelijan arvosana muuttujaan
    arvosana = int(input("Syötä lisättävän opiskelijan arvosana: "))
    # lisätään arvosana kirjastoon käyttäen avaimena annettua nimeä
    opiskelijat[nimi] = arvosana
    
# Jos käyttäjä haluaa poistaa opiskelijan:
elif toiminto == "p":
    # poimitaan poistettavan opiskelijan nimi muuttujaan
    nimi = input("Syötä poistettavan opiskelijan nimi: ").strip()
    # Jos poistettava nimi löytyy avainten joukosta, poistetaan nimi ja arvosana pop()-funktion avulla
    if nimi in opiskelijat.keys():
        opiskelijat.pop(nimi)
    # Jos poistettavaa nimeä ei löydy, ilmoitetaan siitä käyttäjälle
    else:
        print("Antamaasi nimeä ei löytynyt.")

# Tulostetaan lopuksi muokattu lista
print (opiskelijat)


#########################
#
# Luento 4
#
#########################

# Miniprojekti: Keinoälylapsi

# Tuodaan random-moduuli. Tätä käytetään ensimmäisen kysyttävän kysymyksen arpomiseen
import random

# Luodaan lista mahdollisista kysymyksistä
kysymykset = ["Mitä dinosauruksille tapahtui? ", "Miksi taivas on sininen? ", "Onko hirviöitä olemassa? "]

# random-moduulin choice()-funktiolla voidaan valita listan jäsenistä satunnainen arvo.
# Tallennetaan arvottu arvo muuttujaan kysymys
kysymys = random.choice(kysymykset)

# Esitetään valittu kysymys käyttäjälle ja tallennetaan tämän vastaus muuttujaan 'vastaus'
vastaus = input(kysymys).lower().strip()

# Luodaan while-silmukka, jota toistetaan kunnes muuttujan 'vastaus' arvo on "siksi".
while vastaus != "siksi":
    # Esitetään käyttäjälle kysymys "Miksi?" niin kauan kunnes tämä hoksaa vastata "siksi"
    vastaus = input("Miksi? ").lower()

# Tulostetaan lopuksi teksti, josta käy ilmi että vastaus on ymmärretty.
print("Ai joo, selvä.")


# While-silmukkaharjoitukset

# 1 - Lottonumerot

# Tuodaan random-moduuli, jolla arvotaan numerot
import random

# Luodaan tyhjä lista, johon arvotut numerot tallennetaan.
# Tallentamiseen kannattaa käyttää listaa, koska listalle
# jo tallennetut numerot on kätevä tarkastaa in-operaattorin avulla
numerot = []

# Arvotaan numeroita niin kauan kuin listalla on alle seitsemän numeroa
# Silmukasta poistutaan siis kun seitsemäs numero lisätään listalle
while len(numerot) < 7:
    # Arvotaan ensin numero väliltä 1-40 randint()-funktion avulla ja tallennetaan se muuttujaan 'numero'
    numero = random.randint(1,40)
    # tarkastetaan not in -operaattorin avulla onko numero jo listalla 'numerot' vaiko ei
    # Näin varmistutaan ettei listalle päädy monta samaa numeroa
    if numero not in numerot:
        # Jos numero ei vielä ole listalla, lisätään se listalle
        numerot.append(numero)

# Järjestellään numerot ja tulostetaan ne
numerot.sort()
print (numerot)


#2 - numeronarvauspeli

# Tuodaan random-moduuli. Sen avulla arvotaan arvattava numero
import random

# Arvotaan numero, joka käyttäjän tulee arvata, randint()-funktion avulla ja tallennetaan se muuttujaan 'guess'
guess = random.randint(1,20)

# Luodaan muuttuja 'userguess', johon tallennetaan käyttäjän arvaus.
userGuess = 0

# Silmukkaa toistetaan niin kauan kuin käyttäjän arvaus on eri kuin arvattava numero
while userGuess != guess:
  
  # Pyydetään käyttäjää syöttämään arvaus.
  # Koska input()-funktio palauttaa merkkijonon, muunnetaan paluuarvo int()-funktiolla numeroksi ja tallennetaan
  userGuess = int(input("Arvaa mitä numeroa ajattelen: "))
  
  # Tarkastellaan käyttäjän arvausta if-elif-else -rakenteessa
  
  # Jos käyttäjän arvaus on oikein, onnitellaan käyttäjää
  if userGuess == guess:
    print ("Onneksi olkoon! Arvasit oikein!")
  
  # Jos käyttäjän arvaus on suurempi kuin arvattava numero, kerrotaan tämä
  elif userGuess > guess:
    print ("Väärin, ajattelin pienempää numeroa")
  
  # Muussa tapauksessa kerrotaan että arvattava numero on suurempi kuin käyttäjän arvaus
  else:
    print("Väärin, ajattelin suurempaa numeroa")


#3 Käyttäjätunnus ja salasana

# Luodaan muuttuja, joka tarkastelee onko käyttäjä syöttänyt oikean tunnuksen ja salasanan
oikeaTunnus = False
# Luodaan muuttuja, joka tarkastelee montako kertaa käyttäjä on yrittänyt syöttää tunnusta ja salasanaa
laskuri = 0

# Luodaan sanakirja, jossa avaimena on käyttäjänimi ja arvona salasana
users = {"Esko":"Noppa", "Frank":"1234", "Seppo":"Räty"}

# Kysytään käyttäjätunnusta siihen asti kunnes käyttäjä syöttää 
# oikean tunnuksen/salasanan tai ylittää sallitun arvausmäärän
while not(oikeaTunnus) and laskuri < 5:
    # Kysytään käyttäjänimeä ja salasanaa
    nimi = input("Käyttäjätunnus: ").strip() 
    tunnus = input("Salasana: ").strip()

    # Tarkastetaan onko käyttäjän syöttämä käyttäjänimi kirjaston avainten joukossa
    if nimi in users.keys():
        # Tarkastetaanko onko käyttäjän syöttämä salasana sama kuin käyttäjätunnukseen, eli kirjaston 
        # avaimeen, liittyvä arvo. Jos käyttäjä on syöttänyt käyttäjänimen "Esko" ja salasanan "Noppa"
        # tulkitsee python seuraavan rivin muodossa: if users["Esko"] == "Noppa"
        if users[nimi] == tunnus:
            # Jos tunnus ja salasana vastaavat kirjastoon tallennettuja arvoja,
            # muutetaan oikeaTunnus-muuttujan arvoksi tosi. Tällä päästään poistumaan silmukasta
            oikeaTunnus = True
        # Jos tunnus löytyi sanakirjan avaimista, mutta annettu salasana ei vastannut avaimeen tallennettua
        # arvoa, kerrotaan tästä, ja nostetaan käytettyjen yritysten määrää yhdellä
        else:
            print("Väärä käyttäjätunnus tai salasana")
            laskuri = laskuri + 1
    # Jos käyttäjän syöttämää tunnusta ei löydy kirjaston avaimista. Kerrotaan käyttäjälle
    # tietoturvasyistä että tunnus tai salasana oli väärin. Nostetaan myös yritysten määrää yhdellä
    else:
        print("Väärä käyttäjätunnus tai salasana")
        laskuri = laskuri + 1


# Kun silmukasta on poistuttu, kerrotaan käyttäjälle lopputulos.
# Jos käyttäjä syötti oikean tunnuksen ja salasana, muuttujan oikeaTunnus arvo on True.
# Testin voi kirjoittaa myös muodossa if oikeaTunnus == True, mutta lyhyempi muoto on aina parempi.
if oikeaTunnus:
    print("Tervetuloa järjestelmään")
# Jos oikeaTunnus -muuttujan arvo on edelleen alussa määritetty False, käyttäjä ei saanut syötettyä
# oikeaa tunnusta, eikä näin ollen saa pääsyä järjestelmään
else:
    print("Hus, pois täältä!")

    
# For-silmukkaan liittyvät esimerkit:

# Yksinkertainen, range-funktioon perustuva silmukka:
# Silmukan arvoksi määritetään vuoronperää luvut 1-10, koska range-funktiolla
# määritetyn sarjan loppupää ei sisälly läpikäytävään sarjaan
for i in range(1,11):
	# Muuttuja i saa vuoronperää arvokseen luvut 1-10 ja ne tulostetaan näytölle.
  print(i)
  

# Range-funktio on kätevä silloin kun ohjelmassa tarvitsee käydä joku tietty numerosarja läpi numero kerrallaan.
# Tämän avulla voidaan ratkaista vehnänjyvä ja shakkilauta -pulma (https://en.wikipedia.org/wiki/Wheat_and_chessboard_problem)

# Määritetään lähtötilanne muuttujien avulla. Shakkilaudan ensimmäiseen ruutuun tulee yksi jyvä
# ja ennen ensimmäistä silmukan suorituskertaa tallessa on nolla jyvää.
jyvat = 1
yhteensa = 0

# Koska shakkilaudassa on 64 ruutua, laaditaan range-funktiolla sarja,
# jossa on numerot 1-64 (viimeinen luku tippuu taas joukosta pois.
for ruutu in range(1, 65):
  # Kerrotaan tilanne tässä kohtaa silmukkaa, eli missä ruudussa mennään ja monta jyvää ruudussa on.
  # Ensimmäisellä silmukan suorituskerralla ruudussa yksi on yksi jyvä.
	print("Ruudussa {} on {} jyvaa".format(ruutu, jyvat))
	# Lisätään tämänhetkinen jyvämäärä yhteissaldoon.
  	yhteensa += jyvat
  # Koska pulman mukaan seuraavaan ruutuun tulee kaksinkertainen jyvämäärä, kerrotaan jyvien määrä kahdella.
  # Näin ensimmäisessä ruudussa on yksi jyvä, toisessa kaksi, kolmannessa neljä, neljännessä kahdeksan ja niin edelleen.
	jyvat = jyvat * 2

# Kun silmukka on suoritettu 64 kertaa, kerrotaan yhteistulos.
print ("Jyvia kertyi yhteensa {}".format(yhteensa))


# Myös merkkijonot ovat sarjoja, joten myös niitä voi käsitellä for-silmukassa.
# Tässä tapauksessa käsiteltävän sarjan jäseniä ovat yksittäiset kirjaimet.
for kirjain in "abcd":
	# muuttuja 'kirjain' saa ensimmäisellä kerralla arvokseen "a", sitten "b" jne.
	print (kirjain)

# Listoja tai monikkoja käsiteltäessä sarjan jäseniä ovat listan/monikon yksittäiset elementit.
for ostos in ("Maito", "Juusto", "Pekoni", "Nuudelit"):
	# Muuttuja 'ostos' saa ensimmäisellä kerralla arvokseen "Maito", toisella "Juusto" jne.
	print(ostos)
	
	
# Kaksinkertaiset silmukat
# Kaksinkertaisia silmukoita käytetään erilaisten taulukkorakenteiden käsittelyyn.
# Ulomman silmukan voi ajatella vastaavan esim. Excel-taulukon riviä ja sisemmän Excel-taulukon saraketta.
# Tässä tapauksessa ulompaa silmukkaa toistetaan neljä kertaa.
for numeroUlompi in range(1, 5):
	# Ensimmäisellä ulomman silmukan suorituskerralla ohjelma tulostaa rivin "Ulompi silmukka, suorituskerta 1"
    print("Ulompi silmukka, suorituskerta {}".format(numeroUlompi))
	
	# Tämän jälkeen ohjelma jatkaa ulomman silmukan ensimmäisen suorituskerran suorittamista ja kohtaa sisemmän silmukan.
	# Sisempi silmukka on määritetty toistumaan niin ikää neljään kertaan.
    for numeroSisempi in range(1,5):
		# Ulomman silmukan ensimmäinen suorituskerta päättyy vasta kun ohjelma saa suoritettua kaikki ulomman silmukan
		# ohjelmalohkossa olevat koodirivit. Ohjelman tulee suorittaa sisempi silmukka kokonaisuudessaan. 
		# Ensimmäisellä suorituskerralla ohjelma tulostaa siis rivit:
		# Sisempi silmukka, suorituskerta 1
		# Sisempi silmukka, suorituskerta 2
		# Sisempi silmukka, suorituskerta 3
		# Sisempi silmukka, suorituskerta 4
        print ("Sisempi silmukka, suorituskerta {}".format(numeroSisempi))
	# Vasta tämän jälkeen ohjelma voi suorittaa ulomman silmukan toisen suorituskerran.


# Kaksinkertaisista silmukoista on paljon iloa esimerkiksi silloin kun ohjelmassa täytyy käsitellä
# lista, joka sisältää listoja.
# Seuraava lista 'elokuvat' sisältää kolme sisempää lista, 
# joissa kussakin on elokuvan nimi, valmistusvuosi, IMDB-arvosana ja kesto minuutteina.

elokuvat = 	[
			["The Room", 2003, 3.5, 99],
            ["Hot Fuzz", 2007, 7.9, 116],
            ["The World's End", 2013, 7.0, 109]
			]

# Jos listata haluttaisiin tulostaa kaikkien elokuvien tiedot, voi tulostaminen tehdä esim. sisäkkäisten silmukoiden avulla:
# Ulompi silmukka poimii tarkasteltavaksi yhden elokuvan tiedot sisältävän listan kerrallaan.
# Esim. ensimmäisellä suorituskerralla muuttuja 'elokuva' saisi arvokseen sisemmän listan ["Shaun of the Dead", 2004, 8.0, 99].
for elokuva in elokuvat:
	# Koska muuttujan 'elokuva' arvo on vielä tässäkin kohtaa lista, voidaan sitäkin tarkastella silmukassa:
	for tieto in elokuva:
		# Sisempi silmukka suoritetaan taas kokonaan läpi ennen kuin ulompi silmukka jatkaa seuraavalle kierrokselle
		# Näin sisempi silmukka tulostaa ensin rivin "Shaun of the Dead", sitten rivin 2004, sitten 8.0 ja lopuksi 99.
		print(tieto)
		
# Jos tiedot haluaa nätisti yhdelle riville, voi silmukoita muokata näin:

# Ulompi lista käsittelee edelleen elokuvat yksi lista kerrallaan.
for elokuva in elokuvat:	
	
	# Joka kerta kun ulompi silmukka tulostetaan, määritetään muuttuja johon sisemmän listan tiedot tallennetaan:
	leffaTieto = ""
	
	for tieto in elokuva:
		# Sisempi silmukka suoritetaan taas kokonaan läpi ennen kuin ulompi silmukka jatkaa seuraavalle kierrokselle.
		# Lisätään joka suorituskerralla käsiteltävänä oleva tieto muuttujan 'leffaTieto' merkkijonoon.
		# Erikoismerkki '\t' tarkoittaa merkkijonossa muotoiluun käytettävää sarkainmerkkiä.
		leffaTieto += "{}\t".format(tieto)
		
		# Jos muuttujaan tallentaisi arvon muodossa leffaTieto += "{};".format(tieto), eli erottelisi 
		# arvot puolipisteellä, ja tallentaisi merkkijonon tiedostoon, Excel osaisi tulkita tiedoston rivit
		# taulukkomuodossa, CSV-tiedostona.
	
	# Kun sisempi silmukka on suoritettu kokonaan ensimmäisen kerran, 
	# merkkijonoon leffaTieto on tallentunut arvo "The Room\t2003\t3.5\t99\t"
	# Kun tämä arvo on tulostettu, ulomman silmukan ensimmäinen kierros päättyy.
	print (leffaTieto)
			


### Luento 4: Kotitehtävät:

#1.
teksti = input("Syötä teksti jonka haluat tulostaa: ").strip()
kerroin = int(input("Kuinka monta kertaa haluat tulostaa tekstin: "))

for i in range(kerroin):
	print(teksti)
	
	
#2.
ostoslista = []

for i in range(5):
    ostos = input("Syötä tuote jonka haluat lisätä ostoslistalle: ")
    ostoslista.append(ostos)

ostoslista.sort()

for i in range(5):
    print("{}. {}".format(i + 1, ostoslista[i]))

	
#3.
for numero in range(1, 51):  
    if numero % 3 == 0 and numero % 5 == 0:  
        print("fizzbuzz")  
    elif numero % 3 == 0:  
        print("fizz")  
    elif numero % 5 == 0:  
        print("buzz")  
    else:
        print(numero)

		

#########################
#
# Luento 5
#
#########################

# Harjoitus: Tiedostot

# Tehtävä 1.
# Tuodaan os- ja os.path-moduulit
import os,os.path

# Määritetään luettava tiedosto muuttujaan 'polku'
polku = os.path.join("harkka1.txt")

# Avataan tiedosto luku-tilassa ja tallennetaan se muuttujaan 'rivit'
rivit = open(polku, "r")

# Käydään rivit-muuttujaan tallennettu tiedosto läpi rivi kerrallaan.
# Tallennetaan yksittäiset rivit muuttujaan 'rivi' silmukkaa suoritettaessa
# ja tulostetaan ne.
for rivi in rivit:
    print(rivi)

# Lopuksi suljetaan tiedosto
# Suljetaan tiedosto
rivit.close()

# Bonustehtävä
# Jos haluat lukea tiedoston jokaisella rivillä olevan sanan yksittäiseen muuttujaan (jotta sen voisi lukea lauseena):
# 1) luo ensin muuttuja, johon tallennat syntyvän merkkijonon
sisalto = ""
# 2) lue sitten tiedosto rivi kerrallaan for-silmukassa
for rivi in rivit:
	# 3) tallenna joka kierroksella käsittelyvuorossa oleva rivi muuttujan 'sisalto' jatkoksi
	# niin, että lisäät muuttujan alkuun tyhjän välin (etteivät sanat ole kiinni toisissaan)
	# ja niin, että poistat rivin lopusta rstrip()-funktiolla rivivaihdon (\n).
	sisalto += " " + rivi.rstrip("\n")
# 4) Tulosta lopuksi merkkijono
print(sisalto)



# Tehtävä 2
# Tuodaan os- ja os.path-moduulit
import os,os.path

# Määritetään luettava tiedosto muuttujaan polku
polku = os.path.join("harkka2.txt")

# Luetaan tiedoston, tallennetaan sisältö muuttujaan
rivit = open(polku)

# Luodaan lista, johon yksittäiset rivit tallennetaan
lista = []
# Luetaan tiedosto rivi kerrallaan läpi
for rivi in rivit:
	# Tallennetaan jokaisen rivin sisältö listan jäseneksi
    lista.append(rivi)
    # Jos haluat poistaa rivinvaihdot, voit käyttää rstrip-funktiota tallennettavaan riviin
	# lista.append(rivi.rstrip("\n"))
	
# Järjestellään listan sisältö aakkosjärjestykseen	
lista.sort()

# Käydään lista läpi for-silmukassa ja tulostetaan
for rivi in lista:
    print(rivi)

# Poistetaan tiedosto
#os.remove(polku)

#----

# Tehtävä 3
# Tuodaan os- ja os.path-moduulit
import os,os.path

# Määritetään tiedosto, johon sisältö tallennetaan
polku = os.path.join("harkka3.txt")

# Avataan tiedosto kirjoitus-tilassa
tiedosto = open(polku, "w")

# Pyydetään käyttäjää syöttämään sisältö ja tallennetaan tiedostoon
lista = []

# Luodaan while-silmukka joka toistuu siihen asti että listalla on viisi kohtaa
while len(lista) < 5:
    # Pyydetään käyttäjää syöttämään tehtävä
    rivi = input("Syötä ToDo-listalle lisättävä tehtävä: ").strip()
    # Tarkastetaan onko tehtävässä tekstiä ja onko tehtävä jo listalla
    if rivi != "" and rivi not in lista:
        # Lisätään listalle vain uudet tehtävät ja tehtävät joissa on tekstiä
        lista.append(rivi)
    # Muussa tapauksessa ilmoitetaan mikä listalle kelpaa.
    else:
        print("Listalle ei voi tallentaa tyhjiä tehtäviä tai listalla jo olevia tehtäviä.")

# Käydään lista läpi for-silmukassa. Range-funktion parametrina käytetään listan pituutta.
# Jos listalla on viisi kohtaa, range-funktio määritetään käytännössä näin: range(5)
# Tämä luo sarjan jossa on numerot 0, 1, 2, 3 ja 4, jotka vastaavat listan indeksinumeroita
for i in range(len(lista)):
    # Kirjoitetaan tiedostoon järjestysnumero ja sitä vastaava listan kohta.
    # Koska sarja alkaa nollasta, lisätään järjestysnumeroon yksi.
    tiedosto.write("{}. {}\n".format(i + 1, lista[i]))

# Suljetaan tiedosto
tiedosto.close()


### Useiden tietyntyyppisten tiedostojen lukeminen rivi kerrallaan
### Case 1: Tiedostot samassa hakemistossa kuin Python-tiedosto

# Tuodaan os-moduuli
import os

# Luetaan hakemiston sisältö listamuotoon
hakemisto = os.listdir(".")

# Käydään hakemistolistaus läpi tiedostonimi kerrallaan
for tiedosto in hakemisto:
   	# Poimitaan tiedostopääte splitext-funktion avulla talteen
   	paate = os.path.splitext(tiedosto)[1]
   	# Tarkastellaan onko tiedostopääte oikea. Tässä tapauksessa etsitään dita-tiedostoja
   	if paate == ".dita":
		# Avataan vuorossa oleva tiedosto
		lukuTiedosto = open(tiedosto)
      	# Tulostetaan tiedosto rivi kerrallaan ruudulle
      	for rivi in lukuTiedosto:
        	print(rivi)
		# Suljetaan tiedosto if-osion päätteeksi
    	lukuTiedosto.close()

		
### Useiden tietyntyyppisten tiedostojen lukeminen rivi kerrallaan
### Case 2: Tiedostot eri hakemistossa kuin Python-tiedosto
### Tässä esimerkissä python-tiedosto on hakemistossa C:\users\mika\Desktop\Python
### ja muut tiedostot hakemistossa C:\temporary-files


# Tuodaan os-moduuli
import os

# Määritetään hakemisto, josta tietoja haetaan
# Tapa 1, suhteellinen polku Python-kansiosta lukien.
# ".." on tapa peruuttaa yksi hakemistotaso rakenteessa taaksepäin
polku = os.path.join("..", "..", "..", "..", "temporary-files")
# Tapa 2, absoluuttinen polku
# polku = os.path.join("C:", os.sep, "temporary-files")

hakemisto = os.listdir(polku)

# Käydään hakemistolistaus läpi tiedostonimi kerrallaan
for tiedosto in hakemisto:
   	# Poimitaan tiedostopääte splitext-funktion avulla talteen
   	paate = os.path.splitext(tiedosto)[1]
   	# Tarkastellaan onko tiedostopääte oikea. Tässä tapauksessa etsitään dita-tiedostoja
   	if paate == ".dita":
		# Avataan vuorossa oleva tiedosto
		# HUOM! os.listdir-funktio palauttaa VAIN tiedostojen nimet, ei hakemistopolkua.
		# Jotta tiedoston voi avata open-funktiolla, parametrissa tulee ilmoittaa myös hakemistopolku
		# Muuten Python etsii tiedostoa hakemistosta jossa python-tiedosto on, ja antaa virheilmoituksen
		# Siispä, liitetään polku tiedostonimeen:
		nimiJaPolku = os.path.join(polku, tiedosto)
		lukuTiedosto = open(nimiJaPolku)
		# Tai lyhyemmin: lukuTiedosto = open(os.path.join(polku, tiedosto))
		
      	# Tulostetaan tiedosto rivi kerrallaan ruudulle
      	for rivi in lukuTiedosto:
        	print(rivi)
		# Suljetaan tiedosto if-osion päätteeksi
    	lukuTiedosto.close()


### Useiden tietyntyyppisten tiedostojen lukeminen
### Case: Tiettyjen rivien tulostaminen
import os

# Luetaan hakemiston sisältö listaksi
hakemisto = os.listdir(".")

# Käydään hakemistolistaus läpi tiedostonimi kerrallaan
for tiedosto in hakemisto:
	# Poimitaan tiedostopääte splitext-funktion avulla talteen
    paate = os.path.splitext(tiedosto)[1]
	# Tarkastellaan onko tiedostopääte oikea. Tässä tapauksessa etsitään dita-tiedostoja
    if paate == ".dita":
		# Avataan vuorossa oleva tiedosto
		# HUOM! Jos tiedostoja luetaan samasta hakemistosta kuin missa Python-tiedosto on
		# Pelkkä tiedostonimi riittää tiedoston avaamiseen. Jos tiedostot ovat eri hakemistossa
		# kuin Python-tiedosto, tulee avauskomennossa olla myös hakemistopolku. Ks. edellinen esimerkki.
		lukuTiedosto = open(tiedosto)
        # Luetaan rivit listamuotoon readlines()-funktion avulla
        tiedostoRivit = lukuTiedosto.readlines()
        # Tulostetaan tiedoston kolmas rivi (DITA-tiedostoissa kolmannella rivilla on usein juurielementti)
        print (tiedostoRivit[2])
		# Suljetaan tiedosto
        lukuTiedosto.close()


# Miniprojekti: Tekstitutkailija
import os

# Tallennetaan luettavan tiedoston nimi ja mahdollinen polku muuttujaan
flatlandTiedosto = os.path.join("flatland.txt")
# Avataan tiedosto
tiedosto = open(flatlandTiedosto)

# Koska alkuperäisessä tiedostossa rivit ovat maksimissaan 72 merkkiä pitkiä
# emme voi olettaa että yksi rivi sisältää aina yhden lauseen.
# Luetaan siis tiedoston sisältö yhdeksi suureksi merkkijonoksi
# Määritetään ensin muuttuja, johon merkkijono tallennetaan. Muuttuja sisältää aluksi tyhjän merkkijonon
merkkijono = ""

# Ryhdytään lukemaan tiedostoa rivi kerrallaan läpi.
for rivi in tiedosto:
	# Rivi päättyy aina rivinvaihtomerkkiin '\n'. Poistetaan se, jotta merkkijonoon ei tallennu turhia
	# merkkejä. rstrip()-funktio toimii tässä tarkoituksessa kätevästi, sillä se poistaa rivinvaihdon merkkijonon
	# oikeasta reunasta, eli rivin lopusta. Lisätään samalla rivin alkuun välilyönti, jotta teksti ei ole
	# kiinni edellisen rivin viimeisessä merkissä.
    merkkijono += " " + rivi.rstrip('\n')

# Kun koko tiedosto on luettu läpi ja tallennettu yhteen merkkijonoon, voimme pilkkoa merkkijonon listaksi.
# split-funktiolle voi antaa parametriksi merkin, johon listan yksi kohta päättyy ja seuraava alkaa.
# Käytetään pilkkomiseen pistettä, niin saamme katkottua merkkijonon lauseisiin
lauseet = merkkijono.split(".")

# Määritetään muuttuja, johon tallennetaan kokonaissanamäärä
kokSanaMaara = 0

# Käydään lauselista läpi yksi lause kerrallaan
for lause in lauseet:
	# Käytetään taas split-funktiota apuna. Jos funktiolle ei anna parametria,
	# se pilkkoo kohteena olevan merkkijonon välilyöntien kohdalta.
	# Näin saamme muodostettua listan, joka sisältää yksittäisen lauseen sanat.
    lauseenSanat = lause.split()
	# Lisätään kokonaissanamäärään yksittäisen lauseen sanamäärä, jonka saamme 
	# len-funktion avulla. 
    kokSanaMaara += len(lauseenSanat)

# Lasketaan montako sanaa tekstin lauseissa on keskimäärin.
# Tämä onnistuu jakamalla kokonaissanamäärä lauseiden lukumäärällä
sanojaPerLause = kokSanaMaara / len(lauseet)

# Tulostetaan lopuksi saadut tilastotiedot
print("Sanoja yhteensa: {}".format(kokSanaMaara))
print("Lauseita yhteensa: {}".format(len(lauseet)))
# Numeroita tulostettaessa {}-sulkeiden väliin voi määrittää muotoiluohjeita kaksoispisteen perään
# .2f kertoo, että desimaaliluvutsa (float, f) näytetään pisteen jälkeen lukuja kahden desimaalin tarkkuudella
print("Keskim. lausepituus: {:.2f} sanaa".format(sanojaPerLause))


# Tekstintutkailija

# Tuodaan tarvittavat moduulit, os ja re. re sisältää säännölisten lauseiden (regular expressions)
# käsittelyyn käytettävät funktiot
import os, re

tiedosto = open("flatland.txt")
# Luodaan muuttuja 'sisaltoAlkoi', joka ilmaisee käsitteleekö
# ohjelma jo varsinaista tekstisisältöä. Koska tiedoston alussa on tekstiin
# kuulumatonta materiaalia, alkuarvo on False
sisaltoAlkoi = False

# Luodaan merkkijono, johon tekstirivit kirjoitetaan
merkkijono = ""

# Käydään tiedosto läpi rivi kerrallaan
for rivi in tiedosto:
	# Jos rivi sisältää kirjan päättymistä ilmaisevan lauseen, merkitään sisaltoAlkoi-muuttujan arvoksi
	# False. Tällöin tätä riviä, eikä sen jälkeisiä rivejä lisätä muuttujan 'merkkijono' jatkeeksi.
    if ("End of the Project Gutenberg EBook") in rivi:
        sisaltoAlkoi = False

	# jos muuttujan 'sisaltoAlkoi' arvo on true [alla oleva lause vastaa lausetta "if sisaltoAlkoi == True"],
	# vuorossa oleva rivi kuuluu sisältöön ja tulee lisätä muuttujaan 'merkkijono'.
    if sisaltoAlkoi:
		# lisätään sisältö, jonka alkuun on lisätty varmuudeksi tyhjä väli, ja jonka lopusta on karsittu rivinvaihto
        merkkijono += " " + rivi.rstrip('\n')

	# Jos rivi päättyy kolmeen tähteen ja rivinvaihtoon, rivi vastaa kirjan sisällön aloittavaa riviä
	# *** START OF THIS PROJECT GUTENBERG EBOOK FLATLAND ***. Merkitään siis 'sisaltoAlkoi-muuttujan arvoksi True.
	# Tästä eteenpäin rivit lisätään muuttujaan 'merkkijono'
    if rivi == "***\n":
        sisaltoAlkoi = True

# Kun kaikki sisältö on lisätty muuttujaan 'merkkijono', on aika jakaa sisältö lauseisiin.
# Tämä onnistuu re-moduulin split-funktiolla. Funktio katkoo merkkijonon lauseisiin ensimmäiseen 
# parametriin määriteltyjen merkkien kohdalta. Merkit ovat tässä tapauksessa piste, kysymysmerkki ja puolipiste.
# Pistettä ja kysymysmerkkiä edeltää kenoviiva, koska molemmilla merkeillä on erityismerkitys säännöllisissä lauseissa.
# Lisäämällä niiden alkuun kenoviivan, funktio tulkitsee ne tavalliseksi pisteeksi ja kysymysmerkiksi
lauseet = re.split('\.|\?|;', merkkijono)

# Määritetään muuttujat, johon tilastoitavaa tietoa tallennetaan
kokSanaMaara = 0
pisinLausePituus = 0
pisinLause = ""

# Käydään re.split-funktiolla luotu lauselista läpi lause kerrallaan
for lause in lauseet:
	# Jaetaan tavallisella split-funktiolla lause listaksi sanoja. Jos split-funktioon ei anna parametria,
	# funktio jakaa lauseen sanoiksi välilyönnin kohdalta
    lauseenSanat = lause.split()
	# Tarkastetaan onko lauseen pituus pidempi kuin tämänhetkisen pisimmän lauseen pituus
    if len(lauseenSanat) > pisinLausePituus:
		# Jos on, merkitään pisimmälle lauseelle uusi arvo
        pisinLausePituus = len(lauseenSanat)
		# Jos on, tallennetaan lause merkkijonona pisinLause-muuttujan uudeksi arvoksi
        pisinLause = lause
    # Lisätään lauseen pituus kokonaissanamäärään
	kokSanaMaara += len(lauseenSanat)

# Lasketaan lauseiden keskipituus
sanojaPerLause = kokSanaMaara / len(lauseet)

# Tulostetaan lopputulema
print("Sanoja yhteensa: {}".format(kokSanaMaara))
print("Lauseita yhteensa: {}".format(len(lauseet)))
print("Keskim. lausepituus: {:.2f} sanaa".format(sanojaPerLause))
print("Pisimmän lauseen pituus: {} sanaa".format(pisinLausePituus))
print("Pisin lause: {}".format(pisinLause))



### 
# UTF-8-merkistön käyttö.
# Lisäämällä seuraavan rivin, kommenttimerkki mukaanlukien, Pythonin pitäisi osata tulkita ohjelma UTF-8-merkistöä käyttäväksi.
# -*- coding: utf8 -*-

# Funktioharjoitukset


# 1.
# Määritetään funktio nimeltä hello. Koska funktio ei tarvitse ulkopuolista tietoa
# toimiakseen, ei määritetä parametria
def hello():
	# Tulostetaan tervehdys
    print("Moi, käyttäjä!")
# suoritetaan funktio
hello()


# 2.

# Määritetään funktio nimeltä hello. Koska funktio tarvitsee nimen, joka sen tulee 
# tulostaa, määritetään funktiolle asianmukainen parametri
def hello(nimi):
	# Jos nimi-muuttujan arvo ei ole tyhjä merkkijono...
    if nimi != "":
		# Tulostetaan tervehdys nimi-parametrin arvoa käyttäen
        print("Moi, {}".format(nimi))
	# Muussa tapauksessa...
    else:
		# Tervehditään käyttäjää nimellä 'vieras'
        print("Moi, vieras")

# Kysytään käyttäjän nimiä
inputNimi = input("Kerro nimesi: ").strip()
# Suoritetaan funktio hello käyttäen parametrina käyttäjän syöttämää nimeä
hello(inputNimi)

#3.
# Määritetään funktio nimeltä kerro. Koska funktio tarvitsee kaksi kerrottavaa lukua,
# määritetään funktiolle kaksi asianmukaista parametria
def kerro(luku1, luku2):
	# Kerrotaan luvut keskenään
	tulo = luku1 * luku2
	# Tulostetaan kertolaskun tulos
	print ("{} kertaa {} on {}".format(luku1,luku2,tulo))

# Kysytään kerrottavat luvut
luku1 = int(input("Syötä luku: "))
luku2 = int(input("Syötä toinen luku: "))

# Kutsutaan funktiota käyttäen parametreina käyttäjän syöttämiä arvoja
kerro(luku1,luku2)

# 4
#Tuodaan random-moduuli
import random

# Määritetään lausahdeltavat lauseet listamuodossa
lauseet = ["Don’t do bad things, only do good things", "Always treat your neighbour like someone who lives near to you", "Never put a sock in a toaster", "Never put jam on a magnet", "Never throw your Granny in a bag", "Never suck all the juice out of a vampire", "Never lean over on Tuesday"]

# Määritetään funktio (Tapa 1)
def lausahda():
	# Arvotaan monesko listan lause tulostetaan
	# Arvottavan luvun minimiarvo on 0 (listan ensimmäinen elementti) ja listan pituus miinus yksi (listan viimeinen elementti)
	lauseNro = random.randint(0, len(lauseet) - 1)
    # Tulostetaan listasta lause arvottua indeksilukua käyttämällä
	print (lauseet[lauseNro])
	

# Määritetään funktio (Tapa 2)
def lausahda():
	# Poimitaan listasta satunnainen arvo käyttäen random.choice-funktiota
	lauseNro = random.choice(lauseet)
	# Tulostetaan arvottu lause
	print(lauseNro)

# Kutsutaan funktiota	
lausahda()


# Ohjelmarakenne ja funktiot
import os, os.path

# Funktio, joka tarkastaa onko parametrina annettu arvo lopettamista tarkoittava merkkijono
# Funktio palauttaa totuusarvon True, jos arvo tarkoittaa poistumista.
def tarkastaLopetus(hakemisto):
    if hakemisto.upper() == "L":
        return True
    else:
        return False

# Funktio, joka kysyy hakemiston nimeä ja palauttaa sen ohjelmaan
def kysyHakemisto():
    hakemisto = input("Syötä hakemisto, jonka sisällön haluat nähdä, tai 'L' lopettaaksesi: ").strip()
    return hakemisto

# Funktio, joka tarkastaa onko käyttäjän syöttämä hakemisto olemassa ja onko se oikeasti hakemisto
# Funktio palauttaa vahvistetun hakemiston ohjelmaan
def tarkastaHakemisto(hakemisto):
	# Jos hakemistoa ei ole olemassa TAI jos annettu polku ei osoita hakemistoon...
    while not os.path.exists(hakemisto) or not os.path.isdir(hakemisto):
		# Jos kyseessä ei ole hakemisto, tulosta asianmukainen viesti ja pyydä uusi ehdokas
        if not os.path.isdir(hakemisto):
            hakemisto = input("{} ei ole hakemisto. Syötä hakemisto: ".format(hakemisto)).strip()
		# Jos hakemistoa ei ole olemassa, tulosta asianmukainen viesti ja pyydä uusi ehdokas
        else:
            hakemisto = input("Hakemistoa {} ei ole. Syötä hakemisto: ".format(hakemisto)).strip()
	# Palauta tarkistettu hakemisto
    return hakemisto

# Funktio, joka tulostaa parametrina annetun hakemiston sisällön
def tulostaSisalto(hakemisto):
	# Haetaan sisältö
    sisalto = os.listdir(hakemisto)
    print("\nHakemiston {} sisältö:".format(hakemisto))
	# Käy sisältö läpi tiedosto kerrallaan
    for tiedosto in sisalto:
		# os.listdir palauttaa vain tiedostojen nimet. Luo muuttuja 'nimiJaPolku', jossa
		# kerrotaan myös tiedoston hakemistopolku
        nimiJaPolku = os.path.join(hakemisto, tiedosto)
        print (nimiJaPolku)

# Ohjelman suoritusta määrittää lopeta-muuttuja
lopeta = False

# Suorita ohjelmaa niin kauan kuin lopeta-muuttujan arvo on False
while not lopeta:
	# Kysy hakemisto ja ota se talteen
    hakemisto = kysyHakemisto()
	# Tarkasta haluaako käyttäjä poistua ohjelmasta
    lopeta = tarkastaLopetus(hakemisto)
	# Jos lopeta-muuttujan arvo on tarkistuksen jälkeen yhä False (lause vastaa lausetta "if lopeta != True"),
	# jatka ohjelman suorittamista
    if not lopeta:
		# tarkasta hakemisto ja ota mahdollinen korjattu hakemisto talteen
        hakemisto = tarkastaHakemisto(hakemisto)
		# tulosta hakemiston sisältö
        tulostaSisalto(hakemisto)

# Funktioharjoitukset 2

# 1
# Määritetään funktio, joka kysyy käyttäjän nimen. 
# Funktio ei tarvitse ulkopuolista tietoa toimiakseen, joten se ei ota parametria
def kysynimi():
	# Kysy käyttäjän nimeä
    nimi = input("Kerro nimesi: ").strip()
	# Toista kysymystä, jos käyttäjä syöttää tyhjän nimen
    while nimi == "":
        nimi = input("Nimi ei voi olla tyhjä. Kerro nimesi: ")
	# Palauta while-silmukalla poimittu, säännöt täyttävä nimi
    return nimi

# Määritetään funktio, joka tulostaa sille syötetyn nimen
# Funktio tarvitsee tietoonsa tulostettavan nimen, joten määritetään siihen asianmukainen parametri
def tulostanimi(nimi):
    print("Moi {}!".format(nimi))
	
# Kutsutaan nimeä kysyvää funktiota ja poimitaan nimi talteen muuttujaan
annettuNimi = kysynimi()
# Kutsutaan tervehdysfunktiota käyttäen saatua nimeä parametrina
tulostanimi(annettuNimi)

# 2
import os, os.path

# Määritetään funktio joka kysyy hakemistoa. Se ei tarvitse ulkopuolista tietoa,
# joten parametria ei tarvita
def KysyHakemisto():
	# Kysytään käyttäjältä hakemistoehdokas
    hakemisto = input("Syötä hakemisto, jonka sisällön haluat nähdä: ").strip()
	
	# Kysytään uutta ehdokasta jos annettu ehdokas ei ole olemassa TAI ei ole hakemisto
    while not os.path.exists(hakemisto) or not os.path.isdir(hakemisto):
		# Jos annettu ehdokas ei ole hakemisto, tulostetaan asianmukainen viesti ja kysytään uusi ehdokas
        if not os.path.isdir(hakemisto):
            hakemisto = input("{} ei ole hakemisto. Syötä hakemisto: ".format(hakemisto)).strip()
		# Jos annettu ehdokas ei ole olemassa, tulostetaan asianmukainen viesti ja kysytään uusi ehdokas
        else:
            hakemisto = input("Hakemistoa {} ei ole. Syötä hakemisto: ".format(hakemisto)).strip()
	# Palautetaan ehdot täyttävä hakemisto
    return hakemisto

# Kysytään tiedostotyyppiä. Ulkopuolista tietoa ei tarvita, joten myöskään parametria ei siis tarvita
def kysyTiedostotyyppi():
	# Kysytään tiedostotyyppiä
    paate = input("Syötä niiden tiedostojen, jotka haluat nähdä, tiedostopääte (esim. '.txt'): ")
	# Tarkastetaan syöttikö käyttäjä tyhjän viestin. Jos niin käy, kysytään uudestaan
    while paate == "":
        paate = input("Syötä tiedostopääte (esim. '.txt'): ")
	# Palautetaan saatu arvo
    return paate

# Tulostetaan sisältö. Tässä kohtaa funktion tulee tietää mistä hakemistosta sisältöä tulostetaan
# ja millaiset tiedostot poimitaan tulostettavaksi, joten määritetään funktiolle asianmukaiset parametrit
def TulostaSisalto(hakemisto, paate):
    sisalto = os.listdir(hakemisto)
    print("\nHakemiston {} sisältämät {}-tiedosto:".format(hakemisto, paate))
	# Käydään sisältö läpi rivi kerrallaan
    for tiedosto in sisalto:
		# Jos vuorossa olevan tiedoston pääte on oikeanlainen...
        if os.path.splitext(tiedosto)[1] == paate:
			# ...tulostetaan tiedoston nimi
            print (nimiJaPolku)
			
# Kysytään hakemistoa ja otetaan saatu arvo talteen
hakemisto = KysyHakemisto()
# Kysytään tiedostoa ja otetaan saatu arvo talteen
paate = kysyTiedostotyyppi()
# Kutsutaan tulostusfunktiota käyttäen parametreina kysyttyjä arvoja
TulostaSisalto(hakemisto, paate)


# XML-tehtävät 1

import os
import xml.etree.ElementTree as ET

# checkFileType-funktio tarkastaa tiedoston tyypin.
# Funktio ottaa parametrikseen tarkastettavan tiedoston nimen,
# josta funktio lukee tiedostopäätteen. Jos tiedostopääte on 
# funktion odottama ".dita", funktio palauttaa arvon True,
# joka kertoo ohjelmalle, että kyseinen tiedosto on DITA-tiedosto
# ja se voidaan ottaa jatkokäsiteltäväksi
def checkFiletype(file):
	ditaExt = ".dita"
	fileExt = os.path.splitext(file)[1]
	if fileExt == ditaExt:
		return True
	else:
		return False

	  
# isConcept-funktio tarkastaa onko parametrina annettava tiedosto
# concept-muotoinen moduuli. Funktio tekee tämän lukemalla tiedoston
# puurakenteen, poimimalla rakenteesta juurielementin, ja vertaamalla
# juurielementin tag-attribuutin arvoa funktion odottamaan "concept"-arvoon.
# Jos kyseessä on concept-moduuli, funktio palauttaa arvon True
def isConcept(file):
	conceptTag = "concept"
	tree = ET.parse(file)
	root = tree.getroot()
	if root.tag.lower() == conceptTag:
		return True
	else:
		return False

# Oletetaan, että Python-skripti on hakemistossa x:\python\luento7 ja tarkasteltavat
# moduulit ovat hakemistossa x:\python\luento7\tehtava1. Luodaan siis viittaus alihakemistoon "tehtava1"
hakem = "tehtava1"
# Luetaan hakemiston sisältämät tiedostot listaksi
files = os.listdir(hakem)
# Luodaan lista, jolle löydetyt concept-moduulit tallennetaan
conceptLista = []

# Käydään tiedostolista läpi tiedosto kerrallaan
for file in files:
	# os.listdir-funktion palauttama lista sisältää vain tiedostojen nimet.
	# Jotta tiedostoja voitaisiin lukea, täytyy niiden alkuun liittää myös
	# hakemisto, josta tiedostot löytyvät
	fullFile = os.path.join(hakem, file)
	# Tarkastetaan käsittelyvuorossa olevan tiedoston tyyppi.
	# Jos tiedosto on DITA-tiedosto, otetaan se jatkotarkasteluun.
	# Huom! Saman if-lauseen voi kirjoittaa myös muodossa "if checkFileType(fullFile) == True"
	if checkFiletype(fullFile):
		# Tarkastetaan onko tiedoston tyyppi concept
		if isConcept(fullFile):
			# Jos on, lisätään se listalle
			conceptLista.append(file)
			
			
# Tulostetaan lopuksi lista
print(conceptLista)


# XML-tehtävät 2
import os, xml.etree.ElementTree as ET

# checkFileType-funktio tarkastaa tiedoston tyypin.
# Funktio ottaa parametrikseen tarkastettavan tiedoston nimen,
# josta funktio lukee tiedostopäätteen. Jos tiedostopääte on 
# funktion odottama ".dita", funktio palauttaa arvon True,
# joka kertoo ohjelmalle, että kyseinen tiedosto on DITA-tiedosto
# ja se voidaan ottaa jatkokäsiteltäväksi
def checkFiletype(file):
	ditaExt = ".dita"
	fileExt = os.path.splitext(file)[1]
	if fileExt == ditaExt:
		return True
	else:
		return False

# pullFileInfo lukee parametrina annetusta tiedostosta muutamia tietoja.
# funktio ottaa parametrina luettavan tiedoston nimen ja mahdollisen hakemistopolun
# jos tiedosto on eri hakemistossa kuin skripti.
# Funktio lukee tiedoston puumuotoon, tallentaa juurielementin tag-attribuutin arvon,
# juurilementin attribuutin "id" arvon.
# Tämän jälkeen funktio tallentaa nämä tiedot sekä tiedoston nimen sanakirjamuodossa
# muuttujaan fileInfo ja palauttaa muuttujan
def pullFileInfo(file):
	tree = ET.parse(file)
	root = tree.getroot()
	fileId = root.attrib["id"]
	fileType = root.tag
	fileInfo = {"filename":file, "id":fileId, "type":fileType}
	return fileInfo

   
# Oletetaan, että Python-skripti on hakemistossa x:\python\luento7 ja tarkasteltavat
# moduulit ovat hakemistossa x:\python\luento7\tehtava1. Luodaan siis viittaus alihakemistoon "tehtava1"
hakem = "tehtava1"
# Luetaan hakemiston sisältämät tiedostot listaksi
files = os.listdir(hakem)
# Luodaan lista, jolle tarkastettujen moduulien tiedot tallennetaan
ditalista = []

# Käydään tiedostolista läpi tiedosto kerrallaan
for file in files:
	# os.listdir-funktion palauttama lista sisältää vain tiedostojen nimet.
	# Jotta tiedostoja voitaisiin lukea, täytyy niiden alkuun liittää myös
	# hakemisto, josta tiedostot löytyvät
	fullFile = os.path.join(hakem, file)
	# Tarkastetaan käsittelyvuorossa olevan tiedoston tyyppi.
	if checkFiletype(fullFile):
		# Jos vuorossa on DITA-tiedosto, luetaan tiedostosta tiedot ja otetaan palautuva
		# informaatio talteen muuttujaan info
		info = pullFileInfo(fullFile)
		# Lisätään muuttuja info tietolistalle
		ditalista.append(info)

#Tulostetaan listan sisältämät sanakirjat
for item in ditalista:
	print("{}\n".format(item))


# Siivousautomaatti v1


import xml.etree.ElementTree as ET
import os

# Oletetaan, että Python-skripti on hakemistossa x:\python\luento7 ja tarkasteltavat
# moduulit ovat hakemistossa x:\python\luento7\faulty-tasks. Luodaan siis viittaus alihakemistoon "faulty-tasks"
fileDir = os.path.join("faulty-tasks")
fileList = os.listdir(fileDir)

for file in fileList:
	# os.listdir-funktion palauttama lista sisältää vain tiedostojen nimet.
	# Jotta tiedostoja voitaisiin lukea, täytyy niiden alkuun liittää myös
	# hakemisto, josta tiedostot löytyvät.
	fullname = os.path.join(fileDir, file)
	# Ennen kuin tiedostoja käydään lukemaan, tarkastetaan että kyseessä on oikeasti tiedosto.
	# Näin ohjelma ei kompastu mahdollisiin hakemistoihin ja yritä lukea niitä.
	if os.path.isfile(fullname):
		# Luetaan puurakenne muuttujaan tree
		tree = ET.parse(fullname)
		# Poimitaan juurielementti
		root = tree.getroot()
		# Poimitaan shortdesc-elementti luettavaksi
		shortdesc = root.find("shortdesc")
		# Poimitaan taskbody-elementti
		taskbody = root.find("taskbody")
		# Context-elementtiä ei voi sijoittaa taskbody-elementin alle SubElement-funktiolla,
		# koska funktio lisää uuden lapsielementin aina rakenteen viimeiseksi elementiksi ja
		# Context-elementin tulee olla listan alkupäässä.
		# Luodaan siis ensin context-elementti Element-funktion avulla sijoittamatta sitä vielä mihinkään.
		context = ET.Element('context')
		# Tallennetaan context-elementin tekstiksi shortdesc-elementin teksti
		context.text = shortdesc.text
		# Insert-funktion avulla voi sijoittaa Element-funktiolla luodun elementin (tässä tapauksessa context)toisen elementin 
		# lapsielementiksi, ja määrittää mihin kohtaan rakennetta lapsielementti tulee sijoittaa.
		# Sijoitetaan context-elementti indeksiin 0, eli ensimmäiseksi.
		taskbody.insert(0, context)
		# Tämän jälkeen poistetaan shortdesc-elementti
		root.remove(shortdesc)
		# Lopuksi tallennetaan päivitetty puurakenne alkuperäiseen tiedostoon.
		tree.write(fullname)

# Tämä ratkaisumalli toimii vain, jos shortdesc-elementti sisältää ainoastaan tekstiä.
# Jos shortdesc-elementillä on lapsielementtejä, esim. <b>-elementillä luotuja korostuksia,
# teksti katkeaa näiden kohdalla.
# Jos shortdesc sisältää seuraavanlaista sisältöä:
# So, you dirtied your <xref href="moccablaster.making.coffee.with.moccablaster.dita">MoccaBlaster</xref> by using it.
# context-elementtii tallentuu vain sisempää elementtiä edeltävä "So, you dirtied your" -teksti.

# Siivousautomaatti v2

import xml.etree.ElementTree as ET
import os

fileDir = os.path.join("faulty-tasks")
fileList = os.listdir(fileDir)

for file in fileList:
	fullname = os.path.join(fileDir, file)
	if os.path.isfile(fullname):
		tree = ET.parse(fullname)
      	root = tree.getroot()
      	taskbody = root.find("taskbody")
      	shortdesc = root.find("shortdesc")
		# Luodaan context-elementti luomalla viittaus shortdesc-elementtiin.
		# Näin context-elementin alle tallentuvat tekstisisällön ohella myös
		# shortdesc-elementin mahdolliset lapsielementit
		context = shortdesc
		# Muokataan context-elementin tagin nimeksi "context".
		# Huom! Koska muuttujaan ei tallennu varsinainen elementti vaan viittaus
		# muistisijaintiin johon elementti on tietokoneella tallennettu, sekä context-muuttuja
		# että shortdesc-muuttuja viittaavat samaan muistisijaintiin. Näin myös shortdesc-muuttujan tagin arvoksi muuttuu "context".
		# Muutos kohdistuu kuitenkin vain tagiin, ei sen sijaintiin puurakenteessa. Elementti on edelleen task-elementin alla,
		# mutta sen tag muuttuu shortdesc:istä context:iksi
		context.tag = "context"
		# Sijoitetaan context-elementti taskbody-elementin alle
		taskbody.insert(0, context)
		# poistetaan shortdesc-elementti juurielementin alta
		root.remove(shortdesc)
		# Tallennetaan muutokset tiedostoon
		tree.write(fullname)



# Tiedostotehtavat

#1.

# Tuodaan tarvittavat moduulit, shutil ja os
import shutil, os

# Määritetään lähde- ja kohdekansiot os.path.join -moduulin avulla
lahde = os.path.join("x:", os.sep, "tehtava2")
kohde = os.path.join("x:", os.sep, "dita-tiedostot")

# Luetaan lähdehakemiston tiedostolistaus
tiedostot = os.listdir(lahde)

# Tarkastetaan onko kohdehakemisto olemassa. Jos ei, luodaan hakemisto
if not os.path.exists(kohde):
	os.mkdir(kohde)

# Käydään tiedostolistaus läpi tiedosto kerrallaan for-silmukassa:
for tiedosto in tiedostot:
	# os.listdir-funktion palauttama lista sisältää vain tiedostojen nimet.
	# Jotta tiedostoja voitaisiin lukea, täytyy niiden alkuun liittää myös
	# hakemisto, josta tiedostot löytyvät
	tiedostoPolku = os.path.join(lahde, tiedosto)
	# Määritetään haluttu tiedostopääte
	ditaExt = ".dita"
	# Jos käsittelyvuorossa oleva tiedosto vastaa tiedostopäätettä, kopioidaan se.
	if os.path.splitext(tiedostoPolku)[1].lower() == ditaExt:
		shutil.copy(tiedostoPolku, kohde) 


#2.
import shutil, os

# Määritetään lista, jonka jäseniä ovat kielihakemistoja ja tiedostojen kielikoodeja
# vastaavat merkkijonot.
kielet = ["da", "de", "en", "es", "fi", "fr", "nl", "no", "pl", "pt", "sv", "zh"]
# Määritetään lähde- ja kohdekansiot os.path.join -moduulin avulla
lahde = os.path.join("x:", os.sep, "tehtava2b")
kohde = os.path.join("x:", os.sep, "target2b")


# Tarkastetaan onko kohdehakemisto olemassa. Jos ei, luodaan hakemisto
if not os.path.exists(kohde):
	os.mkdir(kohde)

# Käydään tiedostolistaus läpi tiedosto kerrallaan for-silmukassa:
for kieli in kielet:
   # Muodostetaan käsittelyvuorossa olevan kielitiedoston nimi. Esim. uiStrings-fi.txt
   kieliTiedosto = "uiStrings-" + kieli + ".txt"
   # Muodostetaan lähdekansion polku kielikansioineen
   kokoTiedosto = os.path.join (lahde, kieli, kieliTiedosto)
   # Kysytään vahvistus kopiointiin
   kopioi = input ("Kopioidaanko tiedosto %s (K/E)" % kokoTiedosto).strip().lower()

   # Kopioidaan tiedosto, jos vahvistus on saatu
   if kopioi == "k":
		shutil.copy(kokoTiedosto, kohde)

		
# ZIP-tehtävät
# 1.

# Tuodaan tarvittavat moduulit, zipfile ja os
import os, zipfile

# Muodostetaan viittaus purettavaan tiedostoon ja kohdekansioon
tiedosto = os.path.join("C:", os.sep, "tehtava3a.zip")
kohdekansio = os.path.join ("C:", os.sep, "teht3a-puretut")

# Avataan zip-paketti lukutilassa
paketti = zipfile.ZipFile(tiedosto, "r")

# Luetaan zip-paketin tiedostolistaus
tiedostot = paketti.infolist()

# Käydään zip-paketin tiedostolistaus läpi
for tiedosto in tiedostot:
    print ("Puretaan tiedostoa", tiedosto.filename)
	# Puretaan tiedosto paketista kohdekansioon
    paketti.extract(tiedosto, kohdekansio)
	
	
# 2.
import os, zipfile

# Luodaan funktio, joka kysyy käytettävän zip-paketin nimeä
def kysyPaketti():
    paketti = input("Minkä nimiseen zip-pakettiin haluat pakata tiedostot: ").strip()
    while paketti == "":
        paketti = input("Minkä nimiseen zip-pakettiin haluat pakata tiedostot: ").strip()
	# Jos käyttäjä ei syötä paketin nimeen .zip-päätettä, lisätään se paketin nimeen
    if os.path.splitext(paketti)[1] != ".zip":
        paketti = paketti + ".zip"
	# Palautetaan paketin nimi
    return paketti
        
    
# Luodaan funktio, joka pakkaa tiedostot. Parametrina käyttäjän syöttämä paketin nimi
def pakkaaTiedostot(kohdePaketti):
	# Määritetään lähdekansio
    lahdekansio = os.path.join ("c:", os.sep, "tehtava3b")
	# Määritetään lista pakkaukseen hyväksyttävistä tiedostopäätteistä
    okTiedostoPaatteet = [".jpg", ".png", ".gif"]
	# Avataan pakettitiedosto kirjoitustilassa
    paketti = zipfile.ZipFile(kohdePaketti, "w")
	# Poimitaan lista lähdekansion tiedostoista
    tiedostot = os.listdir(lahdekansio)

	# Käydään lähdekansion tiedostot läpi
    for tiedosto in tiedostot:
		# Jos käsittelyvuorossa olevan tiedoston tiedostopääte löytyy hyväksyttävien listalta...
        if os.path.splitext(tiedosto)[1] in okTiedostoPaatteet:
			...määritetään tiedostopolku
            kokoTiedosto = os.path.join("c:", os.sep, "tehtava3b", tiedosto)
            paketti.write(kokoTiedosto, compress_type=zipfile.ZIP_DEFLATED)
        

paketti = kysyPaketti()
pakkaaTiedostot(paketti)


# 3
import os, zipfile

# Määritetään funktio, joka kysyy hakemiston
def kysyHakemisto():
    hakemisto = input("Mihin hakemistoon haluat purkaa DITA-tiedostot: ").strip()
	# Tarkastetaan ettei käyttäjä syöttänyt vahingossa tiedostoon osoittavaa polkua.
	# Jos näin kävi, pyydetään käyttäjää syöttämään uusi polku
    while os.path.isfile(hakemisto):
        hakemisto = input("{} on tiedosto. Syötä hakemisto: ".format(hakemisto)).strip()
	# Jos käyttäjän syöttämää hakemisto ei vielä ole olemassa, luodaan se
    if not os.path.exists(hakemisto):
        os.mkdir(hakemisto)
    return hakemisto

# Määritetään zip-tiedosto, josta tiedostot puretaan
tiedosto = os.path.join("c:", os.sep, "tehtava3c.zip")
# Avataan zip-paketti lukutilassa
paketti = zipfile.ZipFile(tiedosto, "r")
# Luetaan tiedot paketin sisältämistä tiedostoista
tiedostot = paketti.infolist()
# Kysytään hakemisto, johon materiaali puretaan
hakemisto = kysyHakemisto()

# Käydään zip-paketin tiedostolistaus läpi
for tiedosto in tiedostot:
	# Jos vuorossa olevan tiedoston pääte on .dita...
    if os.path.splitext(tiedosto.filename)[1] == ".dita":
		# ...puretaan tiedosto kohdehakemistoon
        paketti.extract(tiedosto.filename, hakemisto)