# Základní import
import module_name
# Import konkrétních prvků
from module_name import element1, element2
# Alternativní způsoby importu, alternativní pojmenování
import module_name as alias
from another_module import element1 as el1, element2 as el2
# Import všech prvků modulu - Nedoporučováno!
from module_name import *

class MyClass:
    some_attr = 5  # class attribute

class_instance = MyClass()
class_instance1 = MyClass()

# ukázka debugger

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

# ukázka: změna hodnoty atributu
class_instance.some_attr = 100

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

2
5
100
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
        self.compute_age()
        print("A new instance created with the following attributes: ")
        print(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)

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

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

87 John 1936
<__main__.Person object at 0x7fc95419b550>

print(type(p1))
print(p1)

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

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)
# 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: 1937

# 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ázat v debuggeru)
x = 67

del x

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

isinstance(s0, Person)

True

isinstance(s0, Student)

True

class Student(Person):  # this is how we define inheritance
    def __init__(self, name, age, grades):
        '''Constructor that sets instance attributes.
        Expects three arguments: name (str), age (int) and grade (float).'''
        Person.__init__(self, name, age)  # 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
print(s1)

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

class Student(Person):  # this is how we define inheritance
    def __init__(self, name, age, grades):  # overriding parent constructor
        '''Constructor that sets instance attributes.
        Expects three arguments: name (str), age (int) and grade (float).'''
        super().__init__(name, age)  # 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: 28

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

# 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, balance = 0):
        self.name = name
        self.balance = balance
    def __str__(self):
        return(f"BankAccount {self.name} :  {self.balance}")
    def deposit(self, amount):
        if (amount < 0):
            print("Invalid deposit amount. Deposit must be a non-negative number.")
        else:    
            self.balance += amount
    def withdraw(self, amount):
        if (amount < 0):
            print("Invalid withdrawal amount. Deposit must be a non-negative number.")
        else:
            if amount <= self.balance:
                self.balance -= amount
            else:
                print("Insufficient funds. Withdrawal unsuccessful.")
    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()

class Rectangle:
    def __init__(self, width, height):
        if width <= 0 or height <= 0:
            raise ValueError("Both width and height must be greater than zero.")
        self.width = width
        self.height = height

    def calculate_area(self):
        return self.width * self.height


class Square(Rectangle):
    def __init__(self, side_length):
        # super().__init__(side_length, side_length)
        Rectangle.__init__(self, side_length, side_length)
        

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):
        s = f"{self.title} by {self.author}"
        return s
    
class Library:
    def __init__(self):
        self.books = []

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

    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 isinstance(book, Book):
            self.books.append(book)
            print(f"Book '{book.title}' added to the library.")
        else:
            print("Invalid book object. Please provide a valid Book instance.")

    def list_books(self):
        print("----------------")
        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")
book3 = Book("The Great Gatsby", "F. Scott Fitzgerald", 1925, "Scribner", "9780743273565")

library = Library()
library.list_books()  

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

library.list_books()  

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

library.list_books()  

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

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

class Point:
    #def __init__(self, x, y, z):
    #    self.x = (x, y, z)

    def __init__(self, *x):
         self.x = x
    
    def compute_distance(self, other):
        if isinstance(other, Point):
            if len(self.x) == len(other.x):
                # Oba body jsou ve stejném prostoru, rovině nebo na přímce
                distance = (sum( (x-y)**2  for (x, y) in zip(self.x, other.x)))**0.5
                return distance
            else:
                raise ValueError("Cannot compute distance between points in different spaces.")
        else:
            raise ValueError("Invalid argument. Please provide a valid Point instance.")
    
    def compute_distance_in_projection(self, other):
        if isinstance(other, Point):
            # Oba body jsou ve stejném prostoru, rovině nebo na přímce
            distance = (sum( (x-y)**2  for (x,y) in zip(self.x, other.x)))**0.5
            return distance
        else:
            raise ValueError("Invalid argument. Please provide a valid Point instance.")

class PlanePoint(Point):
    def __init__(self, x, y):
        # self.x = (x, y)
        super().__init__(x, y)

class LinePoint(Point):
    def __init__(self, x):
        self.x = (x,)


# Příklad použití tříd Point, PlanePoint a LinePoint
point1 = Point(1, 2, 3)
point2 = Point(4, 0, 6)

plane_point1 = PlanePoint(1, 2)
plane_point2 = PlanePoint(4, 5)

line_point1 = LinePoint(1)
line_point2 = LinePoint(4)

try:
    distance_space = point1.compute_distance(point2)
    print(f"Distance in space: {distance_space}")
except ValueError as e:
    print(f"Error: {e}")

try:
    distance_plane = plane_point1.compute_distance(plane_point2)
    print(f"Distance in plane: {distance_plane}")
except ValueError as e:
    print(f"Error: {e}")

try:
    distance_line = line_point1.compute_distance(line_point2)
    print(f"Distance on line: {distance_line}")
except ValueError as e:
    print(f"Error: {e}")

# Příklad chyby - vzdálenost mezi body v různých prostorech
try:
    invalid_distance = point1.compute_distance(plane_point1)
    print(f"Invalid distance: {invalid_distance}")
except ValueError as e:
    print(f"Error: {e}")


# Vzdálenost v projekci
distance_projection = point1.compute_distance_in_projection(line_point2)
print(f"Distance in projection: {distance_projection}")

Distance in space: 4.69041575982343
Distance in plane: 4.242640687119285
Distance on line: 3.0
Error: Cannot compute distance between points in different spaces.
Distance in projection: 3.0

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

Práce se základními moduly standardní knihovny¶

Příkaz `import`¶

Výběr modulů standardní knihovny¶

`math`¶

`cmath`¶

`random`¶

`sys`¶

`os`¶

`pprint`¶

`collections`¶

`itertools`¶

`csv`¶

`json`¶

`argparse`¶

Externí (nestandardní) balíčky a moduly¶

Modulární stavba programu¶

Balíčky¶

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

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

Práce se základními moduly standardní knihovny¶

Příkaz import¶

Výběr modulů standardní knihovny¶

math¶

cmath¶

random¶

sys¶

os¶

pprint¶

collections¶

itertools¶

csv¶

json¶

argparse¶

Externí (nestandardní) balíčky a moduly¶

Modulární stavba programu¶

Balíčky¶

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

Příkaz `import`¶

`math`¶

`cmath`¶

`random`¶

`sys`¶

`os`¶

`pprint`¶

`collections`¶

`itertools`¶

`csv`¶

`json`¶

`argparse`¶

Metoda `init`¶

Metoda `str`¶