TECHS5 2019

harjoitukset_2019.py

# Harjoitus 1
luku1 = 16384
luku2 = 32768
yhteensa = luku1 + luku2
print(yhteensa)

# Palkankorotusautomaatti
# Tuodaan random-moduuli, jonka avulla voi luoda satunnaislukuja
import random

# Määritetään palkka ja korotuksen ala- ja yläraja
palkka = 3500
alaraja = 50
ylaraja = 500

# Arvotaan korotus randint-funktion avulla. Parametreinä käytetään korotuksen
# ala- ja ylärajaa.
korotus = random.randint(alaraja, ylaraja)

# Lasketaan palkka-muuttujalle uusi arvo palkan ja korotuksen avulla
palkka = palkka + korotus
print(palkka)

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

####################################
#
# Luento 2
#
####################################

### Harjoitus 1

# Luodaan muuttujat:
alku = "Minun nimeni on Jaana-Petteri ja olen "
ika = 22
loppu = " vuotta vanha"

# Muodostetaan tulostettava teksti. Muunnetaan numero merkkijonoksi str()-funktion avulla
tuloste = alku + str(ika) + loppu

# Tulostetaan teksti
print (tuloste)



### Harjoitus 2

# Luodaan muuttujat:
nimi = "Jaana-Petteri"
ika = 22
kaupunki = "Kokkola"

# Luodaan viesti ja sijoitetaan siihen placeholderit {}-merkkien avulla.
viesti = "Minun nimeni on {}. Olen {}-vuotias, kotikaupunkini on {} ja pidän Pythonista yli kaiken"

# Muodostetaan tulostettava viesti lisäämällä placeholderien tilalle muuttujat format()-funktiota käyttäen
tuloste = viesti.format(nimi, ika, kaupunki)

print (tuloste)



### Miniprojekti: Sähköpostileikkuri

# Pyydetään käyttäjää syöttämään sähköpostiosoite input()-funktion avulla.
# Poistetaan mahdolliset ylimääräiset välilyönnit strip()-funktiolla.
sposti = input("Syötä sähköpostiosoite: ").strip()

# Poimitaan käyttäjänimi sarjaa läpikäymällä.
# Tässä esimerkissä sarjan alkupiste on sen alku ja päätepiste on kohdassa, jossa on @-merkki. 
# Viimeinen ":1" tarkoittaa, että sarjaa käydään läpi yksi merkki kerrallaan.
kayttaja = sposti[:sposti.index("@"):1]

# Poimi verkkotunnus sarjaa läpikäymällä
# Tässä esimerkissä haluttu sarjan alkupiste on indeksiluku, jossa @-merkki on plus yksi, eli @-merkkiä seuraava merkki.
# Sarja käydään kokonaan loppuun, eli päätepiste on jätetty tyhjäksi.
# Viimeinen ":1" tarkoittaa, että sarjaa käydään läpi yksi merkki kerrallaan.
verkkotunnus = sposti[sposti.index("@") + 1::1]

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

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

# Tulostetaan viesti
print(viesti)



### Harjoitus 3

# Pyydetään käyttäjää syöttämään verkko-osoite input()-funktion avulla.
# Poistetaan mahdolliset ylimääräiset välilyönnit strip()-funktiolla.
url = input("Syötä verkko-osoite: ").strip()

# Poimitaan alkuosaton verkko-osoite.
# Läpikäytävän sarjan alkupiste on kohta, jossa on kaksi "/"-merkkiä perätysten plus kaksi, eli näiden merkkien jälkeinen merkki.
# Sarja käydään kokonaan loppuun, eli päätepiste on jätetty tyhjäksi.
# Viimeinen ":1" tarkoittaa, että sarjaa käydään läpi yksi merkki kerrallaan.
pelkka_osoite = url[url.index("//") + 2::1]

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

# Muotoillaan viesti
viesti = viesti.format(pelkka_osoite)

# Tulostetaan viesti
print(viesti)



### Harjoitus 4

# Valitaan nimi, jota tervehditään erityisen kohteliaasti
nimi = "Mika"

# Pyydetään käyttäjää syöttämään nimi
# Poistetaan ylimääräiset välilyönnit strip()-funktiolla ja muokataan varmuudeksi
# annettu nimi alkamaan isolla alkukirjaimella title()-funktion avulla.
kaytNimi = input("Kerro nimesi: ").strip().title()

# Tarkastetaan ehtolauseessa onko käyttäjän syöttämä nimi sama kuin määrittämämme nimi.
if kaytNimi == nimi:
# Jos on, tulostetaan prameampi tervehdys
    print("Hei {}! On ilo nähdä sinut taas".format(kaytNimi))
# Muussa tapauksessa tulostetaan perustervehdys
else:
    print("Moikka {}.".format(kaytNimi))


    
### Harjoitus 5

# Pyydetään käyttäjää syöttämään vertailtavat luvut.
# Muunnetaan molemmat luvut kokonaisluvuiksi int()-funktiolla,
# koska input()-funktio palauttaa aina merkkijonon.
n1 = int(input("Syötä numero: "))
n2 = int(input("Syötä toinen numero: "))

# Tarkastetaan onko ensimmäinen luku suurempi
if n1 > n2:
    print ("Ensimmäinen numero, {}, on suurempi".format(n1))
# Jos ei, tarkastetaan onko toinen luku suurempi
elif n2 > n1:
    print ("Toinen numero, {}, on suurempi".format(n2))
# Muussa tapauksessa todetaan että luvut ovat yhtä suuria
else:
    print ("Numerot ovat yhtä suuria")
    
    
### Harjoitus 6
# Tuodaan random-moduuli, jotta voimme arpoa satunnaislukuja
import random

# Arvotaan satunnainen kokonaisluku random-moduulin randint()-funktiolla
luku = random.randint(1, 10)

# Pyydetään käyttäjää arvaamaan luku, ja muunnetaan arvaus kokonaisluvuksi int()-funktiolla
arvaus = int(input("Arvaa mitä lukua ajattelen: "))

# Tarkastetaan arvasiko käyttäjä oikein
if arvaus == luku:
    print("Arvasit oikein!")
# Jos ei, tarkastetaan oliko arvaus liian iso
elif arvaus > luku:
    print("Väärin, mietin pienempää lukua: {}".format(luku))
# Muussa tapauksessa todetaan että arvaus oli liian pieni
else:
    print("Väärin, mietin suurempaa lukua: {}".format(luku))


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

# 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},
         }

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!")
            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.")
    
    
#Harjoitus 1A
# A
opiskelijat = {"Jenna-Petteri":4, "Esko-Mörkö": 2, "Toni-Kristiina":3, "Mikko-Annukka":5}
print (opiskelijat)


#Harjoitus 1B
opiskelijat = {"Jenna-Petteri":4, "Esko-Mörkö": 2, "Toni-Kristiina":3, "Mikko-Annukka":5}
opiskelijat_aakkoset = list(opiskelijat.keys())
opiskelijat_aakkoset.sort()

print(opiskelijat_aakkoset)

#Harjoitus 1C
opiskelijat = {"Jenna-Petteri":4, "Esko-Mörkö": 2, "Toni-Kristiina":3, "Mikko-Annukka":5}
print (opiskelijat)

toiminto = input("Haluatko lisätä tai poistaa opiskelijan? L/P: ").strip().lower()

if toiminto == "l":
    nimi = input("Syötä lisättävän opiskelijan nimi: ").strip()
    arvosana = int(input("Syötä lisättävän opiskelijan arvosana: "))
    opiskelijat[nimi] = arvosana
elif toiminto == "p":
    nimi = input("Syötä poistettavan opiskelijan nimi: ").strip()
    if nimi in opiskelijat.keys():
        opiskelijat.pop(nimi)
    else:
        print("Antamaasi nimeä ei löytynyt.")

print (opiskelijat)


# Keinoälynukke
import random

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

kysymys = random.choice(kysymykset)
vastaus = input(kysymys).lower().strip()

while vastaus != "siksi":
    vastaus = input("Miksi? ").lower()

print("Ai joo, selvä.")


#Harjoitus 2A

import random

numerot = []

while len(numerot) < 7:
    numero = random.randint(1,40)
    if numero not in numerot:
        numerot.append(numero)

numerot.sort()
print (numerot)

#Harjoitus 2B
import random

guess = random.randint(1,20)
userGuess = 0

while userGuess != guess:
  
  userGuess = int(input("Arvaa mitä numeroa ajattelen: "))
  
  if userGuess == guess:
    print ("Onneksi olkoon! Arvasit oikein!")
  
  elif userGuess > guess:
    print ("Väärin, ajattelin pienempää numeroa")
  
  else:
    print("Väärin, ajattelin suurempaa numeroa")


#Harjoitus 2C
oikeaTunnus = False
laskuri = 0

users = {"Esko":"Noppa", "Frank":"1234", "Seppo":"Räty"}

while not(oikeaTunnus) and laskuri < 5:
    nimi = input("Käyttäjätunnus: ") 
    tunnus = input("Salasana: ")

    if nimi in users.keys():
        if users[nimi] == tunnus:
            oikeaTunnus = True
        else:
            print("Väärä käyttäjätunnus tai salasana")
            laskuri = laskuri + 1
    else:
        print("Väärä käyttäjätunnus tai salasana")
        laskuri = laskuri + 1

  
if oikeaTunnus:
    print("Tervetuloa järjestelmään")
else:
    print("Hus, pois täältä!")


    
####################################
#
# Luento 5
#
####################################    
    
### Konttikääntäjä v1
    
# Pyydä käyttäjää syöttämään lause
lause = input("Syötä käännettävä lause: ").strip().lower()
uusiLause = ""

# Jaa lause yksittäisiin sanoihin
sanat = lause.split()

# Luo muuttuja, johon tallennat uudet sanat
uudetSanat = []

# Lue sanat yksi kerrallaan ja muunna ne kontinkielisiksi
for sana in sanat:
    # Poimi uuden sanan arvoksi merkkijono "Ko", sitten sanan kirjaimet kolmannesta kirjaimesta eteenpäin
    # sitten väliviiva, sitten sanan ensimmäinen ja toinen kirjain ja lopuksi "ntti".
    uusiSana = "Ko" + sana[2:] + "-" + sana[:2] + "ntti"
    uudetSanat.append(uusiSana)

# yhdistä sanat takaisin lauseeksi
for sana in uudetSanat:
    uusiLause = uusiLause + " " + sana

# tulosta lause ruudulle
print (uusiLause)



### Konttikääntäjä v2

VOKAALIT = "aieouyäö"
uusiLause = ""
lause = input("Syötä käännettävä lause: ").strip().lower()

# Jaa lause yksittäisiin sanoihin
sanat = lause.split()

uudetSanat = []

# Lue sanat yksi kerrallaan ja muunna ne kontinkielisiksi
for sana in sanat:
# Käsittele vokaalilla alkavat sanat eri tavalla
    if sana[0] in VOKAALIT:
        # Poimi uuden sanan arvoksi merkkijono "Ko", sitten sanan kirjaimet toisesta kirjaimesta eteenpäin
        # sitten väliviiva, sitten sanan ensimmäinen kirjain ja lopuksi "ntti", JOS sana alkaa vokaalilla.
        uusiSana = "Ko" + sana[1:] + "-" + sana[:1] + "ntti"
        uudetSanat.append(uusiSana)
    else:
        # Poimi uuden sanan arvoksi merkkijono "Ko", sitten sanan kirjaimet kolmannesta kirjaimesta eteenpäin
        # sitten väliviiva, sitten sanan ensimmäinen ja toinen kirjain ja lopuksi "ntti".
        uusiSana = "Ko" + sana[2:] + "-" + sana[:2] + "ntti"
        uudetSanat.append(uusiSana)

# yhdistä sanat takaisin lauseeksi
#uusiLause = " ".join(uudetSanat)
for sana in uudetSanat:
    uusiLause = uusiLause + " " + sana

    
# tulosta lause ruudulle
print (uusiLause)


######################################
###################################### 
##
##   Luento 6
##
######################################
######################################



## Tiedostojen tutkailu, osa 1
######################################


### Harjoitus 1
######################################

# Tuodaan os- ja os.path-moduulit
import os,os.path

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

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

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

print(sisalto)
# Suljetaan tiedosto
rivit.close()


### Harjoitus 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)

# Listat ovat yksinkertaisin elementti, jonka voi aakkostaa. Tallennetaan siis rivit listalle.
lista = []

# Käydään sisältö läpi ja lisätään joka rivi aiemmin luotuun lista-muuttujaan
for rivi in rivit:
    lista.append(rivi)
 
# Järjesteään lista
lista.sort()

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

# Poistetaan tiedosto
os.remove(polku)


### Harjoitus 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")

# Luodaan viiden kohdan silmukka ja kirjoitetaan numeroitu lista tiedostoon
for i in range(5):
    rivi = input("Syötä ToDo-listalle lisättävä tehtävä: ")
    # Python ei automaattisesti lisää rivinvaihtoa write-komentoa suoritettaessa.
    # Lisätään siis rivinvaihtomerkki \n tiedostoon tallennettavan merkkijonon perään.
    tiedosto.write("{}. {}\n".format(i + 1, rivi))

# Suljetaan tiedosto
tiedosto.close()


### Tekstitutkailija 1
######################################

import os

# Avataan tiedosto
tiedosto = open("flatland.txt")

# Tiedoston sisältö jakautuu niin, että joka rivillä voi olla yksi tai 
# useampia lauseita, tai ei yhtään lausetta. Lausemäärää ei siis voi laskea
# pelkästään rivien perusteella. Pakataan siis koko sisältö yhteen merkkijonoon
# ja tarkastellaan sitä tuonnempana.
merkkijono = ""

# Käydään tiedosto läpi rivi kerrallaan ja tallennetaan joka rivi muuttujan 
# merkkijono jatkoksi.
for rivi in tiedosto:
   # Tiedostossa on poikkeuksellinen rivinvaihto joka rivin päätteeksi. Sitä
   # ei saa poistettua poistamalla rstrip-funktiolla merkkiä \n, vaan funktiolla
   # täytyy poistaa merkkiyhdistelmä \r\n
   # Mahdolliset rivinvaihtomerkit: \r   -- MacOS ennen versiota X
   #                                \n   -- MacOS X ja myöhemmät & Linux
   #                                \r\n -- Windows (useimmiten)

   merkkijono += " " + rivi.rstrip('\r\n')

# Jaetaan merkkijono lauseiksi split-funktion avulla. Split katkaisee merkkijonon
# parametrina annetun merkin kohdalta ja palauttaa palaset listamuodossa.
lauseet = merkkijono.split(".")

# Luodaan kokonaissanamäärää varten muuttuja kokSanaMaara
kokSanaMaara = 0

# Käydään lauseet läpi for-silmukassa
for lause in lauseet:
   # Jaetaan kukin lause sanoiksi. Jos split-funktiolle ei anna parametria,
   # se jakaa merkkijonon paloihin välilyöntien kohdalta.
   lauseenSanat = lause.split()
   # Lisätään lauseenSanat-listan pituus (eli lauseen sanojen määrä) kokonaissanamäärään
   kokSanaMaara += len(lauseenSanat)

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

# Tulostetaan johtopäätökset
print("Sanoja yhteensa: {}".format(kokSanaMaara))
print("Lauseita yhteensa: {}".format(len(lauseet)))
# Jos placeholder-merkkiin sijoittaa numeron, sen desimaalien määrän voi määrittää
# muotoiluoperaattorin avulla.
print("Keskim. lausepituus: {:.2f} sanaa".format(sanojaPerLause))



## Tiedostojen tutkailu, osa 1
######################################


### Harjoitus 1
######################################

# Tuodaan os- ja os.path-moduulit
import os,os.path

# Luetaan hakemisto listaksi
listaus = os.listdir(".")

# Luetaan tiedostot silmukassa
for tiedosto in listaus:
     paate = os.path.splitext(tiedosto)[1]
# Tarkastellaan vain Python-tiedostoja
    if paate == ".py":

        # Avataan tiedosto...
        sisalto = open(tiedosto)
        # ja luetaan se rivi kerrallaan
        for rivi in sisalto:
            # Jos rivillä on merkki #, kyseessä on todennäköisesti kommenttirivi
            if "#" in rivi:
                print(rivi.strip())


### Harjoitus 2
######################################

import os

# Poimitaan tiedostolistaus muuttujaan hakemisto
hakemisto = os.listdir(".")

# Luetaan tiedostolistaus läpi tiedosto kerrallaan
for tiedosto in hakemisto:
    # Poimitaan tiedostopääte
    paate = os.path.splitext(tiedosto)[1]
   
    # JOS pääte on ".dita"...
    if paate == ".dita":
        # ...avataan tiedosto luettavaksi
        lukuTiedosto = open(tiedosto)
        # Luetaan tiedoston kaikki rivit listamuotoon,
        # jotta päästään helposti käsiksi tiettyyn riviin
        tiedostoRivit = lukuTiedosto.readlines()

        # Jos kolmannella rivillä on teksti "task", tiedetään 
        # että kyseessä on task-moduuli.
        if "task" in tiedostoRivit[2]:
            # Luetaan siis moduulin sisältö rivi kerrallaan ja tulostetaan
            for rivi in tiedostoRivit:
                print (rivi)
        # Ja suljetaan tiedosto lopuksi.
        lukuTiedosto.close()


        
## Ikiomat funktiot
######################################


## Harjoitus 1
######################################

def hello():
    print("Moi, käyttäjä!")
	
hello()


## Harjoitus 2
######################################

def hello(nimi = "vieras"):
    print("Moi, {}".format(nimi))
	
inputNimi = input("Kerro nimesi: ").strip()
if inputNimi != "":
    hello(inputNimi)
else:
    hello()

    
## Harjoitus 3
######################################

def kerro(luku1, luku2):
	tulo = luku1 * luku2
	print ("{} kertaa {} on {}".format(luku1,luku2,tulo))

luku1 = int(input("Syötä luku: "))
luku2 = int(input("Syötä toinen luku: "))

kerro(luku1,luku2)


## Harjoitus 4
######################################

import random

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"]

def lausahda():
	lauseNro = random.randint(0, len(lauseet) - 1)
	print (lauseet[lauseNro])
	
	# TAI:
	lauseNro = random.choice(lauseet)
	print(lauseNro)

lausahda()



######################################
###################################### 
##
##   Luento 7
##
######################################
######################################


## Funktiot ja paluuarvot
######################################

## Harjoitus 1
######################################

# Määritetään funktio, joka kysyy nimen
def kysynimi():
   nimi = input("Kerro nimesi: ")
   while nimi == "":
      nimi = input("Nimi ei voi olla tyhjä. Kerro nimesi: ")
   return nimi

# Määritetään funktio, joka tulostaa nimen
def tulostanimi(nimi):
    print("Moi {}!".format(nimi))
	
# Kutsutaan aliohjelmia
annettuNimi = kysynimi()
tulostanimi(annettuNimi)

## Harjoitus 2
######################################

import os, os.path

# KysyHakemisto selvittää hakemiston, jonka sisällön käyttäjä haluaa listata
def KysyHakemisto():
   hakemisto = input("Syötä hakemisto, jonka sisällön haluat nähdä: ")
   # Tarkastetaan onko käyttäjän syöttämä arvo oikeasti hakemisto.
   # Jos ei, kysytään ja tarkastetaan uudestaan.
   while not os.path.isdir(hakemisto):
      hakemisto = input("{} ei ole hakemisto. Syötä hakemisto: ".format(hakemisto))
   # Palautetaan validi arvo
   return hakemisto

# KysyTiedostotyyppi selvittää minkätyyppisiä tiedostoja käyttäjä haluaa nähdä
def KysyTiedostotyyppi():
   # Koska saatavilla ei ole listaa hyväksyttävistä tiedostotyypeistä, 
   # pyydetään käyttäjää syöttämään jotakin muuta kuin tyhjä arvo.
   paate = input("Syötä niiden tiedostojen, jotka haluat nähdä, tiedostopääte (esim. '.txt'): ")
   while paate == "":
      paate = input("Syötä tiedostopääte (esim. '.txt'): ")
   return paate

# TulostaSisältö tulostaa hakemisto-parametrin määrittämästä hakemistosta
# paate-muuttujan mukaiset tiedostot
def TulostaSisalto(hakemisto, paate):
   sisalto = os.listdir(hakemisto)
   print("\nHakemiston {} sisältämät {}-tiedosto:".format(hakemisto, paate))
   for tiedosto in sisalto:
      # Otetaan tiedosto tulostukseen vain, jos sen pääte on sama
      # kuin mitä käyttäjä syötti.
      if os.path.splitext(tiedosto)[1] == paate:
	 # lista, jonka os.listdir() palauttaa, sisältää vain tiedostojen nimet, ei polkua
	 # Luodaan tulostettava nimi, liittämällä hakemisto ja tiedostonimi yhteen.
         nimiJaPolku = os.path.join(hakemisto, tiedosto)
         print (tiedosto)
			
hakemisto = KysyHakemisto()
paate = KysyTiedostotyyppi()
TulostaSisalto(hakemisto, paate)



## Tiedosto-operaatiot
######################################

## Harjoitus 1
######################################

import shutil, os

# Muodostetaan lähde- ja kohdehakemistojen nimet.
# Huomaa, että aina kun polkuun määritetään aseman kirjain (c:\, x:\ jne.), 
# täytyy kirjaimen jälkeen käyttää polkumäärityksessä os.sep-arvoa.
lahde = os.path.join("x:", os.sep,"tehtava2a")
kohde = os.path.join("x:", os.sep, "dita-tiedostot")

# Poimitaan tiedostolistaus
tiedostot = os.listdir(lahde)

# Luodaan kohdekansio, jos sitä ei ole olemassa
if not os.path.exists(kohde):
	os.mkdir(kohde)

# Käydään tiedostolistaus läpi yksi tiedosto kerrallaan
for tiedosto in tiedostot:
	# Jos tiedostopääte on .dita, kopioidaan tiedostot
	if  os.path.splitext(tiedosto)[1].lower() == ".dita":
		# Koska os.listdir() palauttaa vain tiedostonimen, ja kopioinnissa tarvitaan myös polku,
		# muodostetaan se.
		tiedostoPolku = os.path.join(lahde, tiedosto)
		shutil.copy(tiedostoPolku, kohde)


## Harjoitus 2
######################################

import shutil, os

kielet = ["da", "de", "en", "es", "fi", "fr", "nl", "no", "pl", "pt", "sv", "zh"]
lahde = os.path.join("x:", os.sep, "tehtava2b")
kohde = os.path.join("x:", os.sep, "target2b")

# Määritetään aluksi tarvittavat funktiot
def MuodostaTiedostonimet(kieli):
    # Muodostetaan kielitiedoston nimi, esim "uiStrings-fr.txt"
    kieliTiedosto = "uiStrings-" + kieli + ".txt"
    # Muodostetaan kielitiedoston koko tiedostopolku, esim. "X:\tehtava2b\fr\uiStrings-fr.txt"
    kokoTiedosto = os.path.join (lahde, kieli, kieliTiedosto)
    return kokoTiedosto

def KysyKopioidaanko(tiedostonimi):
    kopioidaanko = input("Kopioidaanko tiedosto {} (K/E)".format(tiedostonimi)).strip().lower()
    while kopioidaanko != "k" and kopioidaanko != "e":
        kopioidaanko = input ("Kopioidaanko tiedosto {} (K/E)".format(tiedostonimi)).strip()
    if kopioidaanko == "k":
        return True
    else:
        return False

def KopioiTiedosto(tiedosto):
    shutil.copy(tiedosto, kohde) 


# Luodaan kohdekansio, jos sitä ei ole olemassa
if not os.path.exists(kohde):
   os.mkdir(kohde)


# Käydään kielikoodit läpi yksi kerrallaan ja tutkitaan kopioidaanko materiaali.
for kieli in kielet:
    tiedostonimi = MuodostaTiedostonimet(kieli)
    if KysyKopioidaanko(tiedostonimi):
        KopioiTiedosto(tiedostonimi)
       

	
## Pakatut tiedostot
######################################

	
## Harjoitus 1
######################################

# Tuodaan tarvittavat moduulit
import os, zipfile

# Muodostetaan pakettitiedoston nimi ja kohdekansion nimi
pakettiTiedosto = os.path.join("C:", os.sep, "tehtava3a.zip")
kohdekansio = os.path.join ("c:", os.sep, "teht3a")

# Avataan paketti ja yhdistetään se muuttujaan
paketti = zipfile.ZipFile(pakettiTiedosto, "r")

# Koska paketti puretaan kokonaan, käytetään extractall-funktiota:
paketti.extractall(kohdekansio)
	

## Harjoitus 2
######################################

import os, zipfile

# Määritetään kansio, jossa kuvat ovat
lahdekansio = os.path.join("c:", os.sep, "tekstit", "tehtava3b")
# Määritetään kansio, johon paketti luodaan. Tämän kansion tulee olla olemassa että paketin voi tehdä sinne.
kohdekansio = os.path.join("c:", os.sep, "tekstit", "tehtava3b") 

# Määritetään funktio, joka luo paketin
def LuoPaketti(kohdekansio):
	# Kysytään ensin paketin nimi
    nimi = input("Minkänimiseen pakettitiedostoon haluat pakata kuvat: ")
    while nimi == "":
        nimi = input("Minkänimiseen pakettitiedostoon haluat pakata kuvat: ")
	# Muodostetaan paketin tiedostonimestä (esim. kuvapaketti.zip) ja kohdekansiosta (tässä tapauksessa c:\tehtava3b)
	# paketin koko tiedostopolku (c:\tehtava3b\kuvapaketti.zip)
    paketinNimiJaPolku = os.path.join(kohdekansio, nimi)
	# Luodaan paketti ja liitetään se muuttujaan paketti
    paketti = zipfile.ZipFile(paketinNimiJaPolku, "w", zipfile.ZIP_DEFLATED)
	# Palautetaan juuri luotu paketti muun ohjelman käyttöön
    return paketti

# Määritetään funktio, joka pakkaa tiedostot
def PakkaaTiedosto(tiedosto, paketti):
	# Otetaan käsittelyssä olevan tiedoston tiedostopääte talteen muuttujaan paate
    paate = os.path.splitext(tiedosto)[1].lower()
	# Muodostetaan käsittelyssä olevan tiedoston koko nimi
    kokoTiedosto = os.path.join(lahdekansio, tiedosto)
	# Tarkastetaan paate-muuttujan arvon perusteella onko käsittelyvuorossa oleva tiedosto kuvatiedosto
    if paate == ".png" or paate == ".jpg" or paate == "gif":
		# Jos on, lisätään se zip-pakettiin. toinen parametri tarkoittaa sitä, että tiedosto pakataan 
		# pienempään tilaan samalla kun se lisätään zip-pakettiin.
        paketti.write(kokoTiedosto, compress_type=zipfile.ZIP_DEFLATED)


# Ohjelmarunko
# Luodaan ensin paketti
paketti = LuoPaketti(kohdekansio)

# Poimitaan lähdekansion tiedostolistaus
tiedostot = os.listdir(lahdekansio)

# Käydään tiedostolistaus läpi tiedosto kerrallaan
for tiedosto in tiedostot:
	# Lähetetään jokainen tiedosto PakkaaTiedosto-funktion käsittelyyn
    PakkaaTiedosto(tiedosto, paketti)

# Suljetaan lopuksi paketti, jotta lisätyt tiedostot tallentuvat sinne
paketti.close()


## Harjoitus 3
######################################

# Tuodaan tarvittavat moduulit
import os, zipfile

# Määritetään funktio, joka kysyy kohdehakemiston
def KysyHakemisto():
    kohde = input("Mihin hakemistoon haluat luoda zip-paketin: ").strip()
    while kohde == "":
        kohde = input("Mihin hakemistoon haluat luoda zip-paketin: ").strip()
	# Palautetaan kohdehakemisto muun ohjelman käyttöön.
    return kohde

# Määritetään funktio, joka kysyy käyttäjältä zip-tiedoston nimen,
# jonka käyttäjä haluaa luoda.
def KysyTiedosto():
    kohde = input("Minkä nimisen zip-paketin haluat luoda: ").strip()
    while kohde == "":
        kohde = input("Minkä nimisen zip-paketin haluat luoda: ").strip()
	# Palautetaan tiedoston nimi muun ohjelman käyttöön.
    return kohde

# Määritetään funktio, joka luo kohdehakemiston, jos sitä ei ole jo olemassa.
def LuoKohde(kohde):
    if not os.path.exists(kohde):
        os.mkdir(kohde)

# Määritetään funktio, joka paketoi DITA-tiedostot.
def PaketoiTiedostot(kohde, paketinNimi, tiedostot):
	# Muodostetaan zip-paketin koko polku tiedostonimen ja hakemistopolun avulla
    kohdePaketti = os.path.join(kohde, paketinNimi)
	# Luodaan itse paketti ja liitetään se muuttujaan paketti
    paketti = zipfile.ZipFile(kohdePaketti, "w")
    # Käydään läpi lähdehakemiston tiedostolistaus
	for tiedosto in tiedostot:
		# Jos käsittelyvuorossa on .dita-tiedosto...
        if os.path.splitext(tiedosto)[1].lower() == ".dita":
			# Muodostetaan pakattavan tiedoston koko polku tiedostonimen ja lähdehakemiston polun avulla.
            kokoTiedosto = os.path.join(lahdekansio, tiedosto)
			# Tulostetaan tietoa käyttäjälle
            print("Pakataan tiedosto {} ...".format(kokoTiedosto))
			# Lisätään tiedosto zip-pakettiin
            paketti.write(kokoTiedosto, compress_type=zipfile.ZIP_DEFLATED)
    # Pakkaamisen päätteeksi suljetaan zip-paketti
	paketti.close()
	# Tulostetaan tietoa käyttäjälle
    print("Tiedostot on nyt paketoitu pakettiin {}".format(kohdePaketti))

	
# Varsinainen ohjelmarunko

# Määritetään lähdekansio
lahdekansio = os.path.join ("c:", os.sep, "tekstit")
# Luodaan lähdekansiosta tiedostolistaus
pakattavat_tiedostot = os.listdir(lahdekansio)

# Kysytään kohdehakemiston ja -tiedoston nimi
kohdeHakemisto = KysyHakemisto()
paketinNimi = KysyTiedosto()
#Luodaan kohdehakemisto, jos sitä ei ole
LuoKohde(kohdeHakemisto)
# Paketoidaan tiedostot
PaketoiTiedostot(kohdeHakemisto, paketinNimi, pakattavat_tiedostot)


## XML-tiedostot
######################################

## Harjoitus 1
######################################

import os
import xml.etree.ElementTree as ET

# Tarkastetaan onko tiedosto DITA-tiedosto tiedostopäätteen perusteella
def checkFiletype(file):
	ditaExt = ".dita"
	fileExt = os.path.splitext(file)[1]
	if fileExt == ditaExt:
		return True
	else:
		return False

# Tarkastetaan onko tiedoston juurielementti "concept"
def isConcept(file):
	conceptTag = "concept"
	tree = ET.parse(file)
	root = tree.getroot()
	if root.tag.lower() == conceptTag:
		return True
	else:
		return False

# Määritetään hakemisto ja luetaan sen sisältö
hakem = "tehtava1"
files = os.listdir(hakem)
# Luodaan tyhjä lista, johon löytyneet concept-moduulit lisätään
conceptLista = []

# Käydään läpi tiedostolistaus
for file in files:
	# Luodaan koko vuorossa olevan tiedoston koko hakemistopolku
	fullFile = os.path.join(hakem, file)
	# Tarkastetaan tiedoston tyyppi
	if checkFiletype(fullFile):
		# Tarkastetaan moduulin tyyppi
		if isConcept(fullFile):
			# Jos moduuli on tyyppiä concept, lisätään listalle
			conceptLista.append(file)
			

## Harjoitus 2
######################################

import os, xml.etree.ElementTree as ET

# Tarkastetaan tiedoston tyyppi
def checkFiletype(file):
	ditaExt = ".dita"
	fileExt = os.path.splitext(file)[1]
	if fileExt == ditaExt:
		return True
	else:
		return False

# Luetaan tiedostosta tiedostonimi, moduulin ID ja moduulin tyyppi (concept, task, reference)
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

# Määritetään lähdehakemisto ja luetaan sen sisältö
hakem = "tehtava1"
files = os.listdir(hakem)
# Luodaan tyhjä lista moduulien tietoja varten
ditalista = []

# Käydään tiedostot läpi yksitellen
for file in files:
	fullFile = os.path.join(hakem,file)
	if checkFiletype(fullFile):
		info = pullFileInfo(fullFile)
		ditalista.append(info)
   
# Tulostetaan kerätyt tiedot
for item in ditalista:
	print("{}\n".format(item))
	

## Harjoitus 3
######################################

import os, xml.etree.ElementTree as ET

# Tarkastetaan tiedostotyyppi
def checkFiletype(file):
	ditaExt = ".dita"
	fileExt = os.path.splitext(file)[1]
	if fileExt == ditaExt:
		return True
	else:
	return False

# Luetaan dita-tiedoston tiedostonimi, ID, moduulin tyyppi ja kielikoodi
def pullFileInfo(file):
	tree = ET.parse(file)
	root = tree.getroot()
	lang = root.attrib["{http://www.w3.org/XML/1998/namespace}lang"]
	fileId = root.attrib["id"]
	fileType = root.tag
	fileInfo = {"filename":file, "id":fileId, "type":fileType, "language":lang}
	return fileInfo

# Kirjoitetaan kerätty tieto tekstitiedostoon
def writeFileInfo(info):
	file = open("ditatiedot.csv", "a")
	file.write("{}, {}, {}, {}\n".format(info["filename"],info["id"],info["type"],info["language"]))
	file.close()

files = os.listdir(".")
ditalista = []

for file in files:
	if checkFiletype(file):
		info = pullFileInfo(file)
		ditalista.append(info)
   
for item in ditalista:
	writeFileInfo(item)