C:\Users\aasi\Downloads\

/home/aasi/Downloads/

elukat = ["aasi", "koira", "hirvi"]

print(elukat[0])

nimi = "Tomomi"

syotteet = []
while True:
    syote = input(": ")
    if not syote:
        break
    syotteet.append(syote)

round(tulos, 2)

round(number[, ndigits]) -> number

pituuskertoimet = {
    "in": 2.54,
    "ft": 30.48,
    "yd": 0.9144,
    "mi": 1.609344
}

print(100 * pituukertoimet["yd"])

as
break
continue
def
elif
else
except
False
finally
for
from
if
import
in
None
pass
return
True
try
while
with

print("{artisti} - [{albumi} #{n:02d}] {kappale} [{kesto}]".format(
    artisti="Scandal",
    albumi="Hello World",
    kappale="Image",
    kesto="4:26"
    n=1
))

sanat.sort(key=len, reverse=True)

with open("tilastot.txt") as tilastot:

with open("kokoelma.json", "w") as kokoelma:

with open("logi.txt", "a") as logi:

if x + leveys >= kentan_leveys:

while True:

valinta = input("Tee valintasi: ")
if valinta == "pituus":
    pituus()
elif valinta == "massa":
    massa()
elif valinta == "tilavuus":
    tilavuus()
elif valinta == "lämpötila":
    lampotila()

valinta = input("Tee valintasi: ")
if valinta == "pituus":
    pituus()
elif valinta == "massa":
    massa()
elif valinta == "tilavuus":
    tilavuus()
elif valinta == "lämpötila":
    lampotila()

black,20,10,3,1
red,10,20,4,3
blue,10,-20,-4,3

In [1] "{:.2f} cm".format(10)
Out[1]: "10.00 cm"

In [2]: "{nimi} ({ammatti})".format(nimi="Pekka", ammatti="Puupää")
Out[2]: "Pekka (Puupää)"

In [1]: print("Hei, nimesi on {} ja olit edellisessä elämässäsi {}.".format("norusu-kun", "mursu")
Hei, nimesi on norusu-kun ja olit edellisessä elämässäsi mursu.

In [1]: print("Omenat {1} {0} ja banaanit {2} {0}, yhteensä {3} {0}.".format("kg", 2, 3, 5)
Omenat 2 kg ja banaanit 3 kg, yhteensä 5 kg

In [1]: print("Omenat {omenat} {yksikko} ja banaanit {banaanit} {yksikko}, yhteensä {yht} {yksikko}.".format(omenat=2, banaanit=3, yht=5, yksikko="kg")
Omenat 2 kg ja banaanit 3 kg, yhteensä 5 kg

LEVEYS = 800
KORKEUS = 400

def laske_uusi_sijainti(x, y, x_suunta, y_suunta, nopeus):
    """
    Laskee ruurudlla liikkuvan hahmon uuden sijainnin nykyisen sijainnin, sunntavektorin ja nopeuden 
    perusteella. Hahmo ei voi liikkua kentän rajojen ulkopuolelle. Palauttaa päivitetyn sijainnin.
    """

    x = max(0, min(x + x_suunta * nopeus, LEVEYS))
    y = max(0, min(y + y_suunta * nopeus, KORKEUS))
    return x, y

uusi_x, uusi_y = laske_uusi_sijainti(x, y, 1.0, 0.0, 5)

LEVEYS = 800
KORKEUS = 400

def laske_uusi_sijainti(x, y, x_suunta, y_suunta, nopeus):
    """
    Laskee ruurudlla liikkuvan hahmon uuden sijainnin nykyisen sijainnin, sunntavektorin ja nopeuden 
    perusteella. Hahmo ei voi liikkua kentän rajojen ulkopuolelle. Palauttaa päivitetyn sijainnin.
    """

    x = max(0, min(x + x_suunta * nopeus, LEVEYS))
    y = max(0, min(y + y_suunta * nopeus, KORKEUS))
    return x, y

for i, elain in enumerate(elukat):

n = 0
inventaario = []

def lisaa_inventaarion(tavarat):
    inventaario.extend(tavarat)
    global n
    n += len(tavarat)

tila = {
    "inventaario": [],
    "n": 0
}

def lisaa_inventaarion(tavarat):
    tila["inventaario"].extend(tavarat)
    tila["n"] += len(tavarat)

matka = 10
if matka >= 50: # Ehtolause on epätosi, joten…
    print("Vielä on pitkä matka.")
# …ohjelman suoritus hyppää tänne.

while True:
    # Ikuisesti toistettava koodi

In [1]: doget = ["doggo", "woofer", "doge", "floofer", "pupper"]
In [2]: doget[0]
Out[2]: 'doggo'
In [3]: doget[-1]
Out[3]: 'pupper'
In [4]: doget[4] = "yapper"
In [5]: doget[-1]
Out[5]: 'yapper'

In [1]: doget = ["doggo", "woofer", "doge", "floofer", "pupper"]
In [2]: doget[0]
Out[2]: 'doggo'
In [3]: doget[-2]
Out[3]: 'floofer'
In [4]: doget[3]
Out[4]: 'floofer'

python kokoelma.py kokoelma.json kopio.json

def lue_argumentit(argumentit):
    if len(argumentit) >= 3:
        lahde = argumentit[1]
        kohde = argumentit[2]
        return lahde, kohde
    elif len(argumentit) == 2:
        lahde = argumentit[1]
        return lahde, lahde
    else:
        return None, None            

lahde, kohde = lue_argumentit(sys.argv)

if __name__ == "__main__":
    print(sys.argv)
    eka = sys.argv[1]
    print(eka)

aasi@testikone:/koodaus$ python argv_test.py hemuli ihaa bileet
['argv_test.py', 'hemuli', 'ihaa', 'bileet']
hemuli

def _piirra_pariton_rinnankytkenta(piiri, komponentit, pituusyksikko):
    """
    Piirtää rinnankytkennän, jossa on pariton määrä komponentteja. Kytkentä 
    piirretään piirtokursorin nykyiseen sijaintiin, ja piirron päätteeks 
    kursorin sijainti päivitetään.
    ...
    """
    
    # Jaetaan komponentit kahteen puoliskoon ja keskikomponenttiin
    keski = len(komponentit) // 2
    vasen = komponentit[:keski]
    oikea = komponentit[keski+1:]
    piiri.add(e.DOT)
    
    # tallennetaan keskilinjan sijainti
    piiri.push()
    
    # piirretään vasemman puolen komponentit
    for i, komp in enumerate(vasen[::-1]):
        piiri.add(e.LINE, d="left", l=1)

    # ...

In [1]: doget = ["doggo", "woofer", "doge", "floofer", "pupper"]
In [2]: doget[:2]
Out[2]: ['doggo', 'woofer']
In [3]: doget[2:3]
Out[3]: ['doge']
In [4]: doget[3:]
Out[4]: ['floofer', 'pupper']
In [5]: doget[2:-1]
Out[5]: ['doge', 'floofer']
In [6]: doget[4:10]    # huom ylitys!
Out[6]: ['pupper]

In [1]: doget = ["doggo", "woofer", "doge", "floofer", "pupper"]
In [2]: doget[::2]
Out[2]: ['doggo', 'doge', 'pupper']
In [3]: doget[::-1]
Out[3]: ['pupper', 'floofer', 'doge', 'woofer', 'doggo']

doget = ["doggo", "woofer", "doge", "floofer", "pupper"]

matriisi = [
    [2, 3],
    [5, 2]
]

In [1]: float(5)
Out[1]: 5.0
In [2]: float("5.0")
Out[2]:5.0
In [3]: float("-12.236e3")
Out[3]:-12236.0

>>> float([1, 2, 3])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: float() argument must be a string or a number, not 'list'
>>> float("aasi")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: could not convert string to float: 'aasi'

In [1]: False or "hemuli"
Out[1]: 'hemuli'
In [2]: 0 or True
Out[2]: True
In [3]: 0 and True
Out[3]: 0
In [4]: "aasi" and None
Out[4]: None
In [5]: "aasi" or None
Out[5]: 'aasi'
In[6]: True and "hemuli"
Out[6]: 'hemuli'

nimi = "kapteeni mursuviiksi"
nimi = 'norusu-kun'

vitsi = """
Nalle Puh oli palailemassa koodaus-allnighterista. 
Puolivälissä matkaa hän huomasi olevansa Ihaan pihalla.
"""

In [1]: doget = ["doggo", "woofer", "doge", "floofer", "pupper"]
In [2]: doget.append("yapper")
In [3]: doget.sort()
In [4]: doget
Out[4]: ['doge', 'doggo', 'floofer', 'pupper', 'woofer', 'yapper']

In [1]: nimi = "hemuli"
In [2]: nimi.capitalize()
Out[2]: 'Hemuli'
In [3]: nimi = nimi.upper()
In [4]: nimi
Out[4]: 'HEMULI'
In [5]: nimi.lower()
Out[5]: 'hemuli'

In [1]: doget = ["doggo", "woofer", "doge", "floofer", "pupper"]
In [2]: tuple(doget)
Out[2]: ('doggo', 'woofer', 'doge', 'floofer', 'pupper')

In [1]: (1, 2, 3)
Out[1]: (1, 2, 3)
In [2]: 1, 2, 3
Out[2]: (1, 2, 3)

In [1]: (2)
Out[1]: 2
In [2]: (2, )
Out[2]: (2,)
In [3]: 2,
Out[3]: (2,)

>>> nimi = "tomomi"
>>> nimi.capitalize()
'Tomomi'
>>> nimi
'tomomi'
>>> kopio = nimi
>>> nimi = nimi.capitalize()
>>> kopio
'tomomi'
>>> nimi
'Tomomi'

In [1]: doget = ["doggo", "woofer", "doge", "floofer", "pupper"]
In [2]: doget.append("yapper")
In [3]: doget
Out[3]: ["doggo", "woofer", "doge", "floofer", "pupper", "yapper"]

In [1]: doget = ["doggo", "woofer", "doge", "floofer", "pupper"]
In [2]: koirulit = doget
In [3]: koirulit.append("musta noutaja")
In [4]: doget
Out[4]: ["doggo", "woofer", "doge", "floofer", "pupper", "musta noutaja"]

koko = 40 * 0.8
nopeus = 10 * 0.8
kantama = 200 * 0.8

SKAALAUS = 0.8

x = 3
def esimerkkifunktio():
    muuttuja = 10 * x
    toinen_muuttuja = muuttuja + 100

print(muuttuja)

>>> while True:
...    pass
... 

user@machine:~$ ps ax|grep python3
 5413 pts/4    S+     0:21 python3
user@machine:~$ kill -SIGINT 5413

KeyboardInterrupt
>>> 
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>

In [1]: 5 + 5
Out[1]: 10

In [2]: 5 - 5
Out[2]: 0

In [3]: 2 * 3
Out[3]: 6

In [4]: 4 / 5
Out[4]: 0.8

In [5]: 4 // 5
Out[5]: 0

In [6]: 4 % 5
Out[6]: 4

In [7]: 10 ** 3
Out[7]: 1000

In [1]: print(f"Sarjanumero {12:04}")
Sarjanumero 0012

In [1]: import math
In [2]: print(f"Piin likiarvo: {math.pi:.4f}")
Piin likiarvo: 3.1416

def laske_matka(nopeus, aika):
    matka = nopeus * aika
    return matka

LEVEYS = 800
KORKEUS = 600

def laske_uusi_sijainti(x, y, x_suunta, y_suunta, nopeus):
    x = max(0, min(x + x_suunta * nopeus, LEVEYS))
    y = max(0, min(y + y_suunta * nopeus, KORKEUS))
    return x, y

Tämä ohjelma laskee pallon tilavuuden ja pinta-alan, kun tiedetään pallon ympärysmitta
Anna pallon ympärysmitta: 23
Traceback (most recent call last):
  File "pallo.py", line 14, in 
    sade = laske_sade(piiri)
  File "pallo.py", line 10, in laske_sade
    return piiri / (PI * 2)
TypeError: unsupported operand type(s) for /: 'str' and 'float'

C:\Users\Aasi\Documents\Ohjelmointi\aasigotchi.py

/home/users/Aasi/Ohjelmointi/aasigotchi.py

Ohjelmointi/aasigotchi.py

osamaara, jakojaannos = divmod(jaettava, jakaja)

for i, arvo in enumerate(lista):
    print(f"{i + 1}. {arvo}")

for avain, arvo in sanakirja.items():

Python 3.7.0 (default, May  7 2019, 09:44:49) 
Type 'copyright', 'credits' or 'license' for more information
IPython 6.5.0 -- An enhanced Interactive Python. Type '?' for help.

In [1]:

Python 3.7.0 (default, May  7 2019, 09:44:49) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 

def laske_pallon_ominaisuudet(piiri):
    sade = laske_sade(piiri)
    ala = laske_ala(sade)
    tilavuus = laske_tilavuus(sade)
    return ala, tilavuus

def lue_kansio(kansio, kokoelma):
    print("Avataan kansio:", kansio)
    sisalto = os.listdir(kansio)
    for nimi in sisalto: 
        polku = os.path.join(kansio, nimi)
        if os.path.isdir(polku):
            lue_kansio(polku, kokoelma)
        else:
            try:   
                lue_tiedot(polku, kokoelma)
            except LookupError:
                pass

heksat = {
    "f": 15, 
    "e": 14, 
    "d": 13, 
    "c": 12, 
    "b": 11, 
    "a": 10
}

In [1]: heksat["a"]
Out[1]: 10
In [2]: heksat["5"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: '5'

>>> h = "a"
>>> heksat.get(h, int(h))
10
>>> h = "6"
>>> heksat.get(h, int(h))
6

In [1]: kurssi = {
   ...:     "nimi": "Ohjelmoinnin alkeet",
   ...:     "arvosana": 5
   ...: }
In [2]: kurssi["arvosana"] = 1
In [3]: kurssi["kommentti"] = "Eihän tätä kestä selvin päin"
In [4]: kurssi
Out[4]: 
{'nimi': 'Ohjelmoinnin alkeet',
 'arvosana': 1,
 'kommentti': 'Eihän tätä kestä selvin päin'}

lopputulos = 10 + 2 * (2 + 3)

In [1]: arvosana = input("Anna arvosana: ")
Anna arvosana: 4
In [2]: arvosana
Out[2]: '4'

Kappaleiden lukumäärä: 0.5
Traceback (most recent call last):
  File "kokoelma.py", line 238, in 
    lisaa(kokoelma)
  File "kokoelma.py", line 154, in lisaa
    n = kysy_luku("Kappaleiden lukumäärä: ")
  File "kokoelma.py", line 44, in kysy_luku
    luku = int(input(kysymys))
ValueError: invalid literal for int() with base 10: '0.5'

>>> print("aasi", end="")
aasi>>> 

In [1]: print(1, 2, 3, sep=" - ")
1 - 2 - 3

def valitse_alkiot(data, alku, loppu):
    return []

>>> type(3+3j)
<class 'complex'>

>>> isinstance(3+3j, float)
False
>>> isinstance((3, ), (tuple, list))
True
>>> isinstance([3], (tuple, list))
True

In [1]: int(input("Anna kokonaisluku: ))
Anna kokonaisluku: 4
Out[1]: 4
In [2]: float(4)
Out[2]: 4.0
In [3]: float("1e3")
Out[3]: 1000.0
In [4]: str(5.0)
Out[4]: '5.0'
In [5]: int(2.7)
Out[5]: 2
In [6]: tuple([1, 2, 3])
Out[6]: (1, 2, 3)

LEVEYS = 800
KORKEUS = 400

def laske_uusi_sijainti(x, y, x_suunta, y_suunta, nopeus):
    x = max(0, min(x + x_suunta * nopeus, LEVEYS))
    y = max(0, min(y + y_suunta * nopeus, KORKEUS))
    return x, y

  File "aasi.py", line 1
    if aasi == "ihaa"
                    ^
SyntaxError: invalid syntax

while True:
    syote = input("Anna aasin hännän pituus (tyhjä lopettaa): ")
    if not syote:
        break

for arvo in tulokset:
    if arvo == 0:
        continue

    #tehdään jotain arvolle

for arvo in tulokset:
    if arvo != 0:
        #tehdään jotain arvolle

sijoitukset = ["Hemuli", "Paavo", "Sibul"]
for i, ottelija in enumerate(sijoitukset):
    print("{}. {}".format(i + 1, ottelija))

In [1]: list(enumerate(sijoitukset))
Out[1]: [(0, 'Hemuli'), (1, 'Paavo'), (2, 'Sibul')]

elukoita = ["koira", "kissa", "orava", "mursu", "aasi", "laama"]
for elain in elukoita:
    print(elain)

In [1]: import math
In [2]: math.ceil(2.245346)
Out[2]: 3

In [1]: from math import ceil
In [2]: ceil(2.245346)
Out[2]: 3

In [1]: import math as m
In [2]: m.ceil(2.245346)
Out[2]: 3

summa = 0
while summa < 21:
    summa += random.randint(1, 10)

while True:
    syote = input("Anna komento (tyhjä lopettaa): ")
   if not syote:
       break

with open("tulokset.txt") as tulokset:
    # tiedosto on nyt auki; sen sisältö voidaan lukea
    tulosrivit = tulokset.readlines()

# tiedosto on nyt kiinni; sieltä luetut tulosrivit voidaan edelleen lukea,
# koska ne ovat ohjelman muistissa
for rivi in tulosrivit:
    print(", ".join(rivi))

# tulokset-muuttujassa olevaa tiedostokahvaa sen sijaan ei voi käsitellä
tulokset.read()

ValueError: I/O operation on closed file.