C:\Users\donkey\Downloads\

/home/donkey/Downloads

result(tulos, 2)

round(number[, ndigits]) -> number

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

This program calculates the volume and area of a ball when its circumference is known
Input ball circumference: 23
Traceback (most recent call last):
  File "ball.py", line 14, in 
    radius = calculate_radius(circumference)
  File "ball.py", line 10, in calculate_radius
    return circumference / (PI * 2)
TypeError: unsupported operand type(s) for /: 'str' and 'float'

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

In [1]: print("Hi, your name is {} and in your previous life you were a {}.".format("norusu-kun", "walrus")
Hi, your name is norusu-kun and in your previous life you were a walrus.

In [1]: print("Apples {1} {0} and bananas {2} {0}, {3} {0} in total.".format("kg", 2, 3, 5)
Apples 2 kg and bananas 3 kg, 5 kg in total

In [1]: print("Apples {apples} {unit} and bananas {bananas} {unit}, {total} {unit} in total.".format(
...   :     apples=2, bananas=3, total=5, unit="kg")
Apples 2 kg and bananas 3 kg, 5 kg in total

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
inventory = []

def add_to_inventory(items):
    inventory.extend(items)
    global n
    n += len(items)

state = {
    "inventory": [],
    "n":  0
}

def add_to_inventory(items):
    state["inventory"].extend(items)
    state["n"] += len(items)

>>> name = "tomomi"
>>> name.capitalize()
'Tomomi'
>>> name
'tomomi'
>>> copy = name
>>> name = namecapitalize()
>>> copy
'tomomi'
>>> name
'Tomomi'

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

name = "Tomomi"

inputs = []
while True:
    value = input(": ")
    if not value:
        break
    inputs.append(value)

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

distance = 10
if distance >= 50: # This condition is false, therefore...
    print("A long way to go.")
# …program execution jumps here.

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

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

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

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 _draw_odd_parallel(circuit, components, length_unit):
    """
    Draws a parallel connection with an odd number of components. It is drawn
    to the cursor's current position, and the cursor's position is updated
    after drawing. 
    ...
    """
    
    # components are separated to two sides and the single middle component
    middle = len(components) // 2
    left = components[:middle]
    right = components[middle+1:]
    circuit.add(e.DOT)
    
    # save the middle line's cursor position
    circuit.push()
    
    # drawing left side components
    for i, comp in enumerate(left[::-1]):
        circuit.add(e.LINE, d="left", l=1)

    # ...

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

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

size = 40 * 0.8
speed = 10 * 0.8
range = 200 * 0.8

SCALE_FACTOR = 0.8

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

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

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

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

Programming/donkeygotchi.py

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

In [1]: import math
In [2]: print(f"Approx. value of pi: {math.pi:.4f}")
Approx. value of pi: 3.1416

result = 10 + 2 * (2 + 3)

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

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

name = "captain ruswal"
name = 'norusu-kun'

text = (
    "This is a long "
    "passage of text"
)

text = """
This is two 
Lines of text
"""

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

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

quotient, remainder = divmod(dividend, divider)

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

for key, value in somedict.items():

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.