home = Path.home()
download = Path("Download")
file = Path("rickroll.mp4")

full_path = home / download / file

# typ instance a typ datového typu (třídy)
print(type(78), type(int))
print(type(class_instance), type(MyClass))

<class 'int'> <class 'type'>
<class '__main__.MyClass'> <class 'type'>

class MyClass:
    some_attr = 5  # class attribute

class_instance = MyClass()
class_instance1 = MyClass()

# instance vytváříme stejně jako u známých datových typů:
s = list()
t = list("abc")
print(s, t)

[] ['a', 'b', 'c']

# ukázka: změna hodnoty atributu
print(class_instance.some_attr)
print(class_instance1.some_attr)

class_instance.some_attr = 1

print(class_instance.some_attr)
print(class_instance1.some_attr)

5
5
1
5

class Person:
    '''A class representing a single person's record.'''
    def __init__(self, name, year_of_birth):
        '''Constructor that sets instance attributes.
        Expects two arguments: name (str), age (int).'''
        self.name = name
        self.year_of_birth = year_of_birth
        print("A new instance created with the following attributes: ")
        print(f"name: {self.name}, year of birth: {self.year_of_birth}")
        # z jedné metody mohu volat jinou:
        self.compute_age()
        print("age:", self.compute_age())

    def compute_age(self):
        '''Computes the age of person.'''
        from datetime import datetime
        current_year = datetime.now().year
        return current_year - self.year_of_birth 
        
# create an instance
p1 = Person("John", 1936)

A new instance created with the following attributes: 
name: John, year of birth: 1936
age: 88

# ukázka: atributy a metody - výpis a změna
p1.name, p1.year_of_birth, p1.compute_age()

('John', 1936, 88)

p1.name = "Pepa"
p1.name

'Pepa'

print(p1)

<__main__.Person object at 0x7f7ef136a3c0>

print(type(p1))
print(p1)

<class '__main__.Person'>
<__main__.Person object at 0x7897a04f3770>

a = [1, 2, 3]
print(type(a))
print(a)

<class 'list'>
[1, 2, 3]

class Person:
    '''A class representing a single person's record.'''
    def __init__(self, name, year_of_birth):
        '''Constructor that sets instance attributes.
        Expects two arguments: name (str), age (int).'''
        self.name = name
        self.year_of_birth = year_of_birth
        print("A new instance created with the following attributes: ")
        print(self)
        
    def __str__(self):
        '''Prints formatted information about name and age attributes.'''
        #print("Converting to string...")  # uncomment to see when __str__ gets called
        return f"name: {self.name}, year of birth: {self.year_of_birth}"

    def compute_age(self):
        '''Computes the age of person.'''
        from datetime import datetime
        current_year = datetime.now().year
        return current_year - self.year_of_birth 

# create an instance
p1 = Person("John", 1936)
print(p1)
# change the attribute 'year_of_birth'
p1.year_of_birth = 1937
# print the information
print(p1)

A new instance created with the following attributes: 
name: John, year of birth: 1936
name: John, year of birth: 1936
name: John, year of birth: 1937
The history saving thread hit an unexpected error (OperationalError('attempt to write a readonly database')).History will not be written to the database.

# create an instance
p2 = Person("Jack", 1999)

A new instance created with the following attributes: 
name: Jack, year of birth: 1999

# delete age attribute
del p2.year_of_birth
# try to print it
try:
    print(p2)
# raises exception because attribute year_of_birth does not exist anymore
except AttributeError as error:
    print(f"Error: {error}")

Error: 'Person' object has no attribute 'year_of_birth'

# now delete the instance altogether
del p2
# try to print it
try:
    print(p2)
# raises exception because the variable with name p2 no longer exists
except NameError as error:
    print(f"Error: {error}")

Error: name 'p2' is not defined

# ukázka: že del funguje i pro jiné datové typu (ukázka i v debuggeru)
x = 7
s = [1, 2, 3]
x

7

del x
del s[1]
s

[1, 3]

x

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[30], line 1
----> 1 x

NameError: name 'x' is not defined

class Student(Person):  # this is how we define inheritance
    pass
s0 = Student("Mahulena", 1990)  # we can create a new instance just as before
print("Age:", s0.compute_age())

A new instance created with the following attributes: 
name: Mahulena, year of birth: 1990
age: 34
Age: 34

isinstance(s0, Student), type(s0) == Student

(True, True)

isinstance(s0, Person), type(s0) == Person

(True, False)

class Student(Person):  # this is how we define inheritance
    def __init__(self, name, year_of_birth, grades):
        '''Constructor that sets instance attributes.
        Expects three arguments: name (str), year_of_birth (int) and grade (float).'''
        Person.__init__(self, name, year_of_birth)  # we call parent constructor
        self.grades=grades  # we add another attribute

s1 = Student("Karel", 1995, [1,3,5])  # we redefined the constructor, now it expects three arguments 
print(s1.grades)  # we can access the additional attribute
print("Age:", s1.compute_age())  # access parent method

A new instance created with the following attributes: 
name: Karel, year of birth: 1995
[1, 3, 5]
Age: 29

# použije se metoda předka:
print(s1)

name: Karel, year of birth: 1995

class Student(Person):  # this is how we define inheritance
    def __init__(self, name, year_of_birth, grades):  # overriding parent constructor
        '''Constructor that sets instance attributes.
        Expects three arguments: name (str), year_of_birth (int) and grade (float).'''
        #Person.__init__(self, name, year_of_birth)  # we call parent constructor
        super().__init__(name, year_of_birth)  # we call parent constructor using super()
        self.grades = grades  # we add another attribute. This can be another object

s1=Student("Karel", 1995, [1,3,5])  # we redefined the constructor, now it expects three arguments 
print(s1.grades)  # we can access the additional attribute
print("Age:",s1.compute_age())  # access parent method

A new instance created with the following attributes: 
name: Karel, year of birth: 1995
[1, 3, 5]
Age: 29

class Student(Person):  # this is how we define inheritance
    def __init__(self, name, year_of_birth, grades):
        '''Constructor that sets instance attributes.
        Expects three arguments: name (str), age (int) and grade (float).'''
        self.grades = grades  # we add another attribute
        super().__init__(name, year_of_birth)  # we call parent constructor using super()
    def __str__(self):
        '''Overriding str method.'''
        return f"{super().__str__()}, grades: {self.grades}"
    def __len__(self): # ukázka: len
        return len(self.grades)
    def add_grade(self, grade):
        '''Appends grade to a list of grades.'''
        self.grades.append(grade)
    def compute_grades_mean(self,weights=None):
        '''Computes the mean of all grades.
        Optional argument weights gives weights to grades.
        By default, a simple mean is computed.'''
        if  weights is None:
            return sum(self.grades) / len(self.grades)
        return sum([w*grade for w, grade in zip(weights, self.grades)]) / sum(weights)

s1=Student("Karel", 1995, [1,3,5])  # we redefined the constructor, now it expects three arguments 
# add grades
s1.add_grade(1)
s1.add_grade(2)
print(s1)  # print the instance, calling __str__ method
print("Average grade:", s1.compute_grades_mean())
print("Average weighted grade:", s1.compute_grades_mean([0.5, 2, 5, 1, 1]))

A new instance created with the following attributes: 
name: Karel, year of birth: 1995, grades: [1, 3, 5]
name: Karel, year of birth: 1995, grades: [1, 3, 5, 1, 2]
Average grade: 2.4
Average weighted grade: 3.6315789473684212

# polymorphic behavior with len() function
a = [1, 2, 3, 4, 5]          
b = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)  
c = {'first': 1, 'second': 2}       
d = "nazdárek párek"                

# use the len() function to get the length of each object and print the results
print(f"Length of list 'a': {len(a)}")
print(f"Length of tuple 'b': {len(b)}")
print(f"Length of dictionary 'c': {len(c)}")
print(f"Length of string 'd': {len(d)}")

Length of list 'a': 5
Length of tuple 'b': 10
Length of dictionary 'c': 2
Length of string 'd': 14

# pokud implementujeme magickou metodu __len__(), můžeme i na studenta volat len()
len(s1)

5

# polymorphic behavior with count() method
a = [1, 2, 3, 1, 4, 1, 5]
b = (10, 20, 30, 10, 40, 10, 50)
c = "Living is just eternal pain and suffering. Especially if you are a programmer."

# using count() method with different types
count_in_list = a.count(1)
count_in_tuple = b.count(10)
count_in_string = c.count(" ")

print(f"Count of 1 in list: {count_in_list}")
print(f"Count of 10 in tuple: {count_in_tuple}")
print(f"Count of blank spaces in string: {count_in_string}")

Count of 1 in list: 3
Count of 10 in tuple: 3
Count of blank spaces in string: 12

class BankAccount:
    def __init__(self, name, initial_deposit=0):
        self.name = name
        self.balance = initial_deposit
    def deposit(self, amount):
        if 0 > amount:
            raise ValueError("Invalid transaction")
        self.balance += amount
    def withdraw(self, amount):
        if 0 > amount:
            raise ValueError("Invalid transaction")
        if 0 <= amount < self.balance:
            self.balance -= amount
        else:
            print("Invalid transaction.")
    def get_balance(self):
        return self.balance

a = BankAccount("John Doe")
a.deposit(100)
a.withdraw(50)
assert a.get_balance() == 50, a.get_balance()

a = BankAccount("Peter Pan",100)
a.deposit(100)
a.withdraw(50)
assert a.get_balance() == 150, a.get_balance()

a = BankAccount("Bob Smith", 100)
a.withdraw(500)
assert a.get_balance() == 100, a.get_balance()

Invalid transaction.

class Rectangle:
    def __init__(self, a, b):
         if not isinstance(a, [int, float]) or not isinstance(b, [int, float]):
            raise TypeError("Invalid data type")
        if 0 > a or 0 > b:
            raise ValueError("Invalid shape")
        self.a = a
        self.b = b
    def calculate_area(self):
        return self.a * self.b
    
class Square(Rectangle):
    def __init__(self, a):
        Rectangle.__init__(self, a, a)
        #super().__init__(a, a)
        #self.a = a
        #self.b = a

r = Rectangle(10, 5.5)
assert r.calculate_area() == 55

s = Square(10)
assert s.calculate_area() == 100

s = Square(9)
assert s.calculate_area() == 81

class Book:
    def __init__(self, title, author, year=None, publisher=None, isbn=None):
        self.title = title
        self.author = author
        self.year = year
        self.publisher = publisher
        self.isbn = isbn

    def __str__(self):
        return f"{self.title} by {self.author}"
    
class Library:
    def __init__(self):
        self.books = []

    def add_book(self, book):
        if not isinstance(book, Book):
            raise TypeError("Invalid book object. Please provide a valid Book instance.")
        self.books.append(book)
        print(f"Book '{book.title}' added to the library.")


    def list_books(self):
        if not self.books:
            print("The library is empty.")
        else:
            print("Books in the library:")
            for book in self.books:
                print(book)
        print("")

book1 = Book("The Great Gatsby", "F. Scott Fitzgerald", 1925, "Scribner", "9780743273565")
book2 = Book("To Kill a Mockingbird", "Harper Lee", 1960, "J.B. Lippincott & Co.", "9780061120084")
print(book1)
print(book2)

library = Library()
library.list_books()  

library.add_book(book1)
library.add_book(book2)

library.list_books()

The Great Gatsby by F. Scott Fitzgerald
To Kill a Mockingbird by Harper Lee
The library is empty.

Book 'The Great Gatsby' added to the library.
Book 'To Kill a Mockingbird' added to the library.
Books in the library:
The Great Gatsby by F. Scott Fitzgerald
To Kill a Mockingbird by Harper Lee

class Library:
    def __init__(self):
        self.books = []
        self.borrowed = []

    def add_book(self, book):
        if not isinstance(book, Book):
            raise TypeError("Invalid book object. Please provide a valid Book instance.")
        self.books.append(book)
        print(f"Book '{book.title}' added to the library.")


    def list_books(self):
        if not self.books:
            print("The library is empty.")
        else:
            print("Books in the library:")
            for book in self.books:
                print(book)
        print("")
        
    def borrow_book(self, name):
        for book in self.books:
            if book.title == name:
                self.books.remove(book)
                self.borrowed.append(book)
                return
        raise ValueException(f"Book called {name} not available.")
                
    def return_book(self, name):
        for book in self.borrowed:
            if book.title == name:
                self.borrowed.remove(book)
                self.books.append(book)
                return
        raise ValueException(f"Book called {name} not borrowed.")


book1 = Book("The Great Gatsby", "F. Scott Fitzgerald", 1925, "Scribner", "9780743273565")
book2 = Book("To Kill a Mockingbird", "Harper Lee", 1960, "J.B. Lippincott & Co.", "9780061120084")

library = Library()
library.list_books()  

library.add_book(book1)
library.add_book(book2)
library.add_book(book1) 

library.list_books()  

library.borrow_book("The Great Gatsby")
library.borrow_book("The Great Gatsby")  

library.return_book("The Great Gatsby")
library.return_book("The Great Gatsby")  

library.list_books()

The library is empty.

Book 'The Great Gatsby' added to the library.
Book 'To Kill a Mockingbird' added to the library.
Book 'The Great Gatsby' added to the library.
Books in the library:
The Great Gatsby by F. Scott Fitzgerald
To Kill a Mockingbird by Harper Lee
The Great Gatsby by F. Scott Fitzgerald

Books in the library:
To Kill a Mockingbird by Harper Lee
The Great Gatsby by F. Scott Fitzgerald
The Great Gatsby by F. Scott Fitzgerald

class FileWriter:
    pass


file_writer = FileWriter("example.txt")

file_writer.append_text("Hello, this is line 1.")
file_writer.append_text("And this is line 2.")

print("Content of the file:")
print(file_writer.get_text())

file_writer.clear_file()

print("\nContent of the file after clearing:")
print(file_writer.get_text())

file_writer.append_text("This is a new line after clearing.")
print("\nUpdated content of the file:")
print(file_writer.get_text())

file_writer.delete_file()

Cvičení č. 21 rozšířené o poznámky ze cvičení a řešení některých příkladů (ZS 2024/25)¶

V minulém díle jste viděli...¶

Modul `pathlib` a třída `Path`¶

Objektově Orientované Programování (OOP)¶

Metoda `init`¶

Metoda `str`¶

Zapouzdření¶

Dědění¶

Polymorfismus¶

Příklady¶

1) Bankovní účet¶

2) Geometrické tvary¶

3) Knihovna¶

4) Lepší knihovna¶

5) Zapisovatel do souboru¶

6) Body v prostoru¶

7) Vlastní datová struktura¶

8) Vylepšení předchozích příkladů¶

Cvičení č. 21 rozšířené o poznámky ze cvičení a řešení některých příkladů (ZS 2024/25)¶

V minulém díle jste viděli...¶

Modul pathlib a třída Path¶

Objektově Orientované Programování (OOP)¶

Metoda __init__¶

Metoda __str__¶

Zapouzdření¶

Dědění¶

Polymorfismus¶

Příklady¶

1) Bankovní účet¶

2) Geometrické tvary¶

3) Knihovna¶

4) Lepší knihovna¶

5) Zapisovatel do souboru¶

6) Body v prostoru¶

7) Vlastní datová struktura¶

8) Vylepšení předchozích příkladů¶

Modul `pathlib` a třída `Path`¶

Metoda `init`¶

Metoda `str`¶