import random

def create_username(fullname):
    """Generates a username based on first and last name"""
    first_name, last_name  = fullname.lower().split()
    username = first_name[:3] + last_name[:3]
    return username


def create_password(letters = 8):
    """Generate a random password"""
    consonants = list('bcdfghjklmnpqrstvwxz')
    vowels = list('aeioyu')

    password = ""

    for i in range(0, letters):
        if i % 2 == 0:
            password += random.choice(vowels)
        else:
            password += random.choice(consonants)

    password += str(random.randrange(10, 99))
    return password

import usermanager

username = usermanager.create_username('Markus Pettersson')
password = usermanager.create_password()

print('Användarnamn:', username)
print('Lösenord:', password)

import usermanager as um

username = um.create_username('Markus Pettersson')
password = um.create_password()

print('Användarnamn:', username)
print('Lösenord:', password)

from usermanager import create_username

username = create_username('Markus Pettersson')
print('Användarnamn:', username)

def do_stuff():
  """Do important stuff"""
  print('Doing stuff.')


def do_more_stuff():
  """Doing more important stuff"""
  print('Doing more stuff.')


def main():
  """Main function. Will run at start"""
  print('Running program.')
  do_stuff()
  do_more_stuff()

# If-satsen kollar ifall vi är i huvudprogrammet.
# Om den här python-filen är importerad som en modul i ett annat
# program kommer inte main-funktionen att köras. 
if __name__ == '__main__':
  main()

# Gå igenom en lista och gör alla strängar till VERSALER

fruits = ['apple', 'banana', 'kiwi', 'pear', 'pineapple']
upper_fruits = [f.upper() for f in fruits]

print(upper_fruits)

# → ['APPLE', 'BANANA', 'KIWI', 'PEAR', 'PINEAPPLE']

fruits = ['apple', 'banana', 'kiwi', 'pear', 'pineapple']
long_fruit_names = [f for f in fruits if len(f) > 4]

print(long_fruit_names)

# → ['apple', 'banana', 'pineapple']

def get_grade(score):
  ''' Return a grade (A-F) depending of test score'''
  if score  > 90:
    return 'A'
  elif score > 80:
    return 'B'
  elif score > 70:
    return 'C'
  elif score > 60:
    return 'D'
  elif score > 50:
    return 'E'
  return 'F'

# En lista med testresultat
scores = [23, 45, 12, 56, 78, 23, 95, 54, 82, 34, 45]

# Skapa en ny lista med betyg (baserat på testresultat)
grades = [get_grade(score) for score in scores]

print(grades)

grades = ['D', 'C', 'A', 'D', 'F', 'D', 'A', 'E', 
          'B', 'D', 'E', 'E', 'F', 'E', 'B', 'F']

grade_options = ('A', 'B', 'C', 'D', 'E', 'F')

summary = {grade: grades.count(g) for g in grade_options}
print(summary)

# {'A': 2, 'B': 2, 'C': 1, 'D': 4, 'E': 4, 'F': 3}

column_1 = [row[0] for row in data]

import csv

# Öppna filen
with open('favourites.csv', newline='') as csvfile:
    csvreader = csv.reader(csvfile)
    # Hoppa över första raden (med kolumnrubriker)
    next(csvreader)

    # Andvänd list comprehension för att skapa en 
    # lista med första kolumnens värden
    icecream = [row[0] for row in csvreader]

# Skapa ett set med alla unika värde (alla olika glass-sorter)
unique_values = set(icecream)

# Skapa en lista med tuplar för varje glass-sort
# Första positionen i tupeln blir glassens namn, 
# den andra är andelen svar
result = [(i, icecream.count(i) / len(icecream)) for i in unique_values]

# Skriv ut resultatet på ett prydligt sätt med f-strings
for r in result:
    print(f'{r[0].capitalize():<13} {r[1]:>5.1%}')

# Definiera en klass

class Dog:
    """A class representing a dog."""
    def __init__(self, name, age):
        self.name = name    # attribut
        self.age = age

    def bark(self):         # metod
        print(f"{self.name} säger: Voff!")


# Skapa objekt (instanser)
elmo = Dog("Elmo", 3)
fido = Dog("Fido", 5)


# Använda metoder och attribut
elmo.bark()        
print(fido.age)


# →'Elmo säger: Voff!'
# → 5

class Animal:
    """A class representiong an animal"""
    def __init__(self, name):
        self.name = name

    def eat(self, food):
      print(f'Yummy, {food}!')
      self.speak()

    def speak(self):
        return "Pip"


# Här är en klass för en hund som ärver från Animal
class Dog(Animal):
    """A class representing a dog"""
    def speak(self):
        print("Voff!")


# Här är en klass för en katt som ärver från Animal
class Cat(Animal):
    """A class representing a cat"""
    def speak(self):
        print("Mjau!")


elmo = Dog('Elmo')
sigge = Cat('Sigge')

elmo.eat('korv')
sigge.eat('fisk')

class Post:
    """ A class representing a blog post"""
    def __init__(self, title, content, author):
        self.title = title
        self.content = content
        self.author = author

    def save(self):
        """Saves the post to the database"""
        # TODO: Implement database saving
        pass

    def delete(self):
        """Delete the blog post"""
        # TODO: Implement database deletion
        pass

    def display(self):
        """Shows the post"""
        print(self.title)
        print(self.author)
        print(self.content)


post = Post(
        "A blogpost", 
        "This is my first post!", 
        "marpet"
      )

post.display()

import json

# Öppna och läs filen
with open("movies.json", "r", encoding="utf-8") as file:
    # Avkodar JSON till Python-objekt (lista med dictionaries)
    movies = json.load(file)  

# Skriv ut titlar och årtal
for movie in movies:
    print(movie["title"], "-", movie["year"])
    main_cast = ', '.join(movie['main_cast'])
    print('Actors: ' + main_cast)
    print('------------------------------------')

import json

game_data = {
  'xp': 12,
  'levels': 5,
  'play_time': 512,
  'inventory': ['diamond pickaxe', 'ender eye'],
  "location": {'x': 123, 'y': 234, 'z': 65}
}

# Spara speldata till en fil
with open("save_file.json", "w", encoding="utf-8") as file:
    json.dump(game_data, file, indent=4) 

print("Data sparad till save_file.json")

days = ['Måndag', 'Tisdag', 'Onsdag', 'Torsdag', 'Fredag']
food = ['kebab', 'pizza', 'sushi', 'meatballs', 'tacos']

menu = zip(days, food)
menu = dict(menu)

print(menu)

# → {'Måndag': 'kebab', 'Tisdag': 'pizza', 'Onsdag': 'sushi', 
#     'Torsdag': 'meatballs', 'Fredag': 'tacos'}

user = ['Markus Pettersson', 'marpet', 'supersecret']

name, username, password = user

print('Namn:', name)
print('Användarnamn:', username)
print('Lösenord:', password)

fav_movies = ['Toy Story 2', 'Toy Story', 
              'Finding Nemo', 'Inside Out']

for number, movie in enumerate(fav_movies, start=1):
    print(number, movie)# → 1 Toy Story 2
#    2 Toy Story
#    3 Finding Nemo
#    4 Inside Out

test_result = [
  {
    'student': 'Orvar Orvarsson',
    'class': 'TETE28',
    'score': 25
  },
  {
    'student': 'Anders Andersson',
    'class': 'TETE28',
    'score': 12
  },
  {
    'student': 'Nils Nilsson',
    'class': 'TETE28',
    'score': 42
  },  
]

ranking = sorted(test_result, key=lambda tr: tr['score'], reverse=True)

scores = [23, 45, 12, 56, 78, 23, 95, 54, 82, 34, 45]
grades = ['F', 'F', 'F', 'E', 'C', 'F', 
          'A', 'E', 'B', 'F', 'F']

for score, grade in zip(scores, grades):
    print(f"Score: {score} → Grade: {grade}")

# Score: 23 → Grade: F
# Score: 45 → Grade: F
# Score: 12 → Grade: F
# ...

a_students = {'Gert', 'Berit', 'Eivor', 'Fanny'}

# Lägg till ett värde till set
a_students.add('Kjell')

# Ta bort ett värde från ett set
a_students.discard('Gert')

print(a_students)

# Alla elever i klassen
students = {'Anna', 'Bertil', 'Ceasar', 
            'David', 'Erik', 'Frida'}

# Närvarande elever
attending = {'David', 'Anna', 'Erik', 'Frida'}

# Vilka elever är frånvarande? Skillnaden mellan mängderna.
absent = students.difference(attending)

print(absent)

# → {'Bertil', 'Ceasar'}

# Alla elever i klassen
students = {'Anna', 'Bertil', 'Ceasar', 
            'David', 'Erik', 'Frida'}

# Mina vänner
friends = {'Ines', 'David', 'Henrik', 'Lisa', 
           'Erik', 'Frida', 'Johan', 'Klas'}

# Vilka av mina vänner går i min klass?
friends_in_class = friends.intersection(students)

print(friends_in_class)

# → {'Frida', 'David', 'Erik'}

# Vi vill ta reda på vilka elever i matte 5-gruppen 
# som inte går teknik eller natur

# Teknikelever
te_class = {'Adrian', 'Berit', 'Cathrine', 'Didrik', 'Eivor', 
            'Fanny', 'Gert', 'Hans', 'Igor', 'Jannike'}

# Naturelever
na_class = {'Krister', 'Lars', 'Marit', 'Noah', 'Ofelia',
            'Petrus', 'Qasim', 'Rickard', 'Steve', 'Thomas'}

# Elever i matte 5
ma5_group = {'Berit', 'Igor', 'Steve', 'Ulf', 
             'Marit', 'Qasim', 'Adrian', 'Gert', 
             'Wincent', 'Noah', 'Victor', 'Hans'}

# Förena natur- och teknikklasserna med .union
te_and_na = te_class.union(na_class)

# Ta reda på vilka i matte 5 som inte finns i klasserna
other = ma5_group.difference(te_and_na)

print(other)

# → {'Wincent', 'Ulf', 'Victor'}

# Teknikelever
te_class = {'Adrian', 'Berit', 'Cathrine', 'Didrik', 'Eivor', 
            'Fanny', 'Gert', 'Hans', 'Igor', 'Jannike'}

# A-elever
a_students = {'Gert', 'Berit', 'Eivor', 'Fanny'}

print(a_students.issubset(te_class))

# → True

# Simulerar en global variabel för inloggningsstatus
user_logged_in = False

# Här är vår decorator-funktion
def require_login(func):
    """Decorator checks if logged in."""
    def wrapper(*args, **kwargs):
        if not user_logged_in:
            print("Åtkomst nekad. Du måste logga in först.")
            return
        # Om användaren är inloggad körs den riktiga funktionen
        return func(*args, **kwargs)
    return wrapper


@require_login
def view_profile():
    print("Visar användarprofilen.")

@require_login
def edit_profile():
    print("Profil uppdaterad!")


# Anropa funktionen utan att vara inloggad
view_profile()      

# Simulera en inloggning
user_logged_in = True

# Anropa funktionen som inloggad
view_profile()

def summa(*args):
    """Sums all arguments"""
    return sum(args)

print(summa(1, 2, 3))  # → 6
print(summa(5, 10))    # → 15

def print_key_and_value(**kwargs):
    """Print key and value from keyword arguments"""
    for key, value in kwargs.items():
        print(f"{key} = {value}")

skriv_ut(name="Elmo", breed="Cavapoo")

# → name = Elmo
#    breed = Cavapoo

def exempel(*args, **kwargs):
    """Prints arguments and keyword arguments"""
    print("args:", args)
    print("kwargs:", kwargs)

exempel(1, 2, 3, a=4, b=5)

# → args: (1, 2, 3)
# → kwargs: {'a': 4, 'b': 5}

def factorial(n):
    """Calculate factorial for number n"""

    # Ifall numret är 0 eller 1 avsluta med att returnera 1
    if n == 0 or n == 1:
        return 1
    # Annars använd rekursion och anropa sig själv    
    else:
        return n * factorial(n - 1)

print(factorial(5))

# → 120

def fibonacci(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n-1) + fibonacci(n-2)

fib_series = [fibonacci(n) for n in range(10)]
print(fib_series)  

import os

def list_files(folder):
    """Prints all files and folder, including subfolders."""
    for item in os.listdir(folder):
        path = os.path.join(folder, item)
        if os.path.isfile(path):
            print(path)  # Hittad fil
        elif os.path.isdir(path):
            list_files(path)  # Gå in i undermappen 

# Exempel: lista alla filer i mappen 'images'
list_files("images")

def encode(message):
    """Returns a list of Unicode values."""
    return [ord(l) for l in message]

def decode(codes):
    """Processes a list of Unicode values. Returns a str"""
    return ''.join([chr(i) for i in codes])

coded_message = encode("I like Python")

print(coded_message)
print(decode(coded_message))