Skip to content

Instantly share code, notes, and snippets.

@mikahimself
Last active Apr 3, 2019
Embed
What would you like to do?
TECHS5 2019
# 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)
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment