C:\Users\donkey\Downloads\

/home/donkey/Downloads

nimi = "Tomomi"

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

round(tulos, 2)

round(number[, ndigits]) -> number

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

In [1]: False or "eeyore"
Out[1]: 'eeyore'
In [2]: 0 or True
Out[2]: True
In [3]: 0 and True
Out[3]: 0
In [4]: "donkey" and None
Out[4]: None
In [5]: "doneky" or None
Out[5]: 'donkey'
In[6]: True and "eeyore"
Out[6]: 'eeyore'

python collection.py collection.json copy.json

def read_arguments(arguments):
    if len(arguments) >= 3:
        source = arguments[1]
        target = arguments[2]
        return source, target
    elif len(arguments) == 2:
        source = arguments[1]
        return source, source
    else:
        return None, None

source, target = read_arguments(sys.argv)

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

donkey@testmachine:/coding$ python argv_test.py hagrid eeyore party
['argv_test.py', 'hagrid', 'eeyore', 'party']
hagrid

if x + width >= field_width:

while True:

if choice == "length":
    length()
elif choice == "mass":
    mass()
elif choice == "volume":
    volume()
elif choice == "temperature":
    temperature()

if choice == "length":
    length()
elif choice == "mass":
    mass()
elif choice == "volume":
    volume()
elif choice == "temperature":
    temperature()

WIDTH = 800
HEIGHT = 400

def calculate_new_position(x, y, x_direction, y_direction, speed):
    x = max(0, min(x + x_direction * speed, WIDTH))
    y = max(0, min(y + y_direction * speed, HEIGHT))
    return x, y

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

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

In [1]: course = {
   ...:     "name": "Elementary Programming",
   ...:     "feedback": 5
   ...: }
In [2]: course["feedback"] = 1
In [3]: course["comment"] = "Can't deal with this sober"
In [4]: course
Out[4]: 
{'name': 'Elementary Programming',
 'feedback': 1,
 'comment': "Can't deal with this sober"}

  File "unitvector.py", line 1
    def calculate_unit_vector(x0, y0, x1, y1)
                                             ^
SyntaxError: invalid syntax

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

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

In [2]: "{name} ({profession})".format(nimi="Woody", ammatti="Woodpecker")
Out[2]: "Woody (Woodpecker)"

WIDTH = 800
HEIGHT = 400

def calculate_new_position(x, y, x_direction, y_direction, speed):
    """
    Calculates the position of a character based on its current position,
    directional vector and speed. The character cannot move out of bounds. 
    Returns the character's new position.
    """

    x = max(0, min(x + x_direction * speed, WIDTH))
    y = max(0, min(y + y_direction * speed, HEIGHT))
    return x, y

new_x, new_y = calculate_new_position(x, y, 1.0, 0.0, 5)

WIDTH = 800
HEIGHT = 400

def calculate_new_position(x, y, x_direction, y_direction, speed):
    """
    Calculates the position of a character based on its current position,
    directional vector and speed. The character cannot move out of bounds. 
    Returns the character's new position.
    """

    x = max(0, min(x + x_direction * speed, WIDTH))
    y = max(0, min(y + y_direction * speed, HEIGHT))
    return x, y

for i, animal in enumerate(animals):

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.

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]: doggos = ["doggo", "woofer", "doge", "floofer", "pupper"]
In [2]: doggos[0]
Out[2]: 'doggo'
In [3]: doggos[-2]
Out[3]: 'floofer'
In [4]: doggos[3]
Out[4]: 'floofer'

while True:
    # Code that's repeated infinitely

In [1]: grade = input("Enter grade: ")
Enter grade: 4
In [2]: grade
Out[2]: '4'

def calculate_ball_attributes(circumference):
    radius = calculate_radius(circumference)
    area = calculate_area(radius)
    volume = calculate_area(radius)
    return area, volume

animals = ["donkey", "dog", "moose"]

print(animals[0])

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

print("{artist} - [{album} #{n:02d}] {song} [{length}]".format(
    artist="Scandal",
    album="Hello World,
    song="Image",
    length="4:26",
    n=1
))

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

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)

    # ...

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

matrix = [
    [2, 3],
    [5, 2]
]

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

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

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

In [1]: name = "hagrid"
In [2]: name.capitalize()
Out[2]: 'Hagrid'
In [3]: name = name.upper()
In [4]: name
Out[4]: 'HAGRID'
In [5]: name.lower()
Out[5]: 'hagrid'

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

In [1]: doggos = ["doggo", "woofer", "doge", "floofer", "pupper"]
In [2]: doggus = doggos
In [3]: doggus.append("kooldoge")
In [4]: doggos
Out[4]: ["doggo", "woofer", "doge", "floofer", "pupper", "kooldoge"]

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

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

SKAALAUS = 0.8

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

• "w", write, which overwrites anything that may have been in the file previously with the new content.
• "a", append, which writes the contents to the end of an existing file instead

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

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

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

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

>>> 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.

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

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

>>> print("Sarjanumero {:04}".format(12)
Sarjanumero 0012

>>> import math
>>> print("Piin likiarvo: {:.4f}".format(math.pi)
3.1416

C:\Users\Donkey\Documents\Programming\donkeygotchi.py

/home/users/Donkey/Programming/donkeygotchi.py

Programming/donkeygotchi.py

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'

• try-lohkon koodia suoritetaan siihen saakka, kunnes se loppuu, tai kun try-lohkon koodi aiheuttaa poikkeuksen.
• except-lohkon koodi suoritetaan ainoastaan, jos try-lohkon koodissa törmätään except-lohkolle määriteltyyn poikkeukseen.
• else-lohko suoritetaan vain siinä tapauksessa, että try-lohko suoritettiin onnistuneesti ilman poikkeuksia.
• finally-lohko suoritetaan lopuksi aina riippumatta siitä, onnistuiko try-lohkon koodi vai aiheuttiko se poikkeuksen.

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

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

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 read_folder(folder, collection):
    print("Opening folder:", folder)
    contents = os.listdir(folder)
    for name in contents:
        path = os.path.join(folder, name)
        if os.path.isdir(path):
            read_folder(path, collection)
        else:
            try:
                read_metadata(path, collection)
            except tinytag.TinyTagException:
                print("Skipping", name)

def calculate_distance(speed, time):
    distance = speed * time
    return distance

WIDTH = 800
HEIGHT = 400

def calculate_new_position(x, y, x_direction, y_direction, speed):
    x = max(0, min(x + x_direction * speed, WIDTH))
    y = max(0, min(y + y_direction * speed, HEIGHT))
    return x, y

x = 3
def example_function():
    variable = 10 * x
    another_variable = variable + 100

print(variable)

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

lopputulos = 10 + 2 * (2 + 3)

In [1]: doggos = ["doggo", "woofer", "doge", "floofer", "pupper"]
In [2]: doggos[:2]
Out[2]: ['doggo', 'woofer']
In [3]: doggos[2:3]
Out[3]: ['doge']
In [4]: doggos[3:]
Out[4]: ['floofer', 'pupper']
In [5]: doggos[2:-1]
Out[5]: ['doge', 'floofer']
In [6]: doggos[4:10]    # note going outside the list
Out[6]: ['pupper]

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

def choose_values(data, start, end):
    return []

• In Windows you can open the terminal by typing cmd to the start menu search
• In Mac OS X you can start the terminal by typing terminal to Finder
• In Linux you can open the terminal from the desktop by pressing Ctrl + Alt + T or by typing terminal to the search

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'

In [1]: doggos = ["doggo", "woofer", "doge", "floofer", "pupper"]
In [2]: tuple(doggos)
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,)

In [1]: int(input("Give an integer: ))
Give an integer: 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)

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

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

while True:
    value = input("Give a donkey's tail length (leave empty to quit): ")
    if not value:
        break

for value in results:
    if value == 0:
        continue

    # do something to the value

for value in results:
    if value != 0:
        # do something to the value

rankings = ["Hagrid", "Spongebob", "Trump"]
for i, contestant in enumerate(rankings):
    print("{}. {}".format(i + 1, contestant))

In [1]: list(enumerate(rankings))
Out[1]: [(0, 'Hagrid'), (1, 'Spongebob'), (2, 'Trump')]

animals = ["dog", "cat", "squirrel", "walrus", "donkey", "llama"]
for animal in animals:
    print(animal)

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("results.txt") as results:
    # the file is now open, and we can read its contents
    result_rows = results.readlines()

# the file is now closed, but we can still access the contents
# because they were saved to program memory earlier
for row in result_rows:
    print(", ".join(row))

# however we can no longer do anything with file handle in results variable
results.read()

ValueError: I/O operation on closed file.