Kurzy programovacího jazyka Python
kurzy.python@centrum.czhttps://github.com/tisnik/python-programming-courses–
"""Kostra jednoduché třídy reprezentující zaměstnance."""
class Employee:
"""Kostra třídy reprezentující zaměstnance."""
pass
"""Kostra jednoduché třídy reprezentující zaměstnance."""
class Employee:
"""Kostra třídy reprezentující zaměstnance."""
pass
# vytvoření dvou instancí třídy
employee1 = Employee()
employee2 = Employee()
# výpis hodnot objektů
print(employee1)
print(employee2)
selfJménoTřídy.jménoAtributuclass CLS:
x = 10
c1 = CLS()
print(CLS.x)
print(c1.x)
c1.x = 20
print(CLS.x)
print(c1.x)
class Employee:
"""Třída reprezentující zaměstnance."""
__counter = 0
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
self._first_name = first_name
self._surname = surname
self._salary = salary
Employee.inc_counter()
def display_employee(self):
"""Metoda pro výpis hodnoty objektu."""
print(
"Full name: {name} {surname} Salary: {salary}".format(
name=self._first_name, surname=self._surname, salary=self._salary
)
)
@classmethod
def inc_counter(cls):
cls.__counter += 1
@classmethod
def num_employees(cls):
return cls.__counter
def test():
# vytvoření dvou instancí třídy
employee1 = Employee("Eda", "Wasserfall", 10000)
print("Now we have", Employee.num_employees(), "employees")
employee2 = Employee("Přemysl", "Hájek", 25001)
print("Now we have", Employee.num_employees(), "employees")
test()
print("Now we have", Employee.num_employees(), "employees")
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Ukázka jednoduché třídy reprezentující zaměstnance."""
class Employee:
"""Třída reprezentující zaměstnance."""
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
self._first_name = first_name
self._surname = surname
self._salary = salary
# vytvoření dvou instancí třídy
employee1 = Employee("Eda", "Wasserfall", 10000)
employee2 = Employee("Přemysl", "Hájek", 25001)
# výpis hodnot objektů
print(employee1._first_name)
print(employee2._first_name)
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Ukázka jednoduché třídy reprezentující zaměstnance."""
class Employee:
"""Třída reprezentující zaměstnance."""
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
print("Konstruktor:", first_name, surname)
self._first_name = first_name
self._surname = surname
self._salary = salary
def __del__(self):
"""Destruktor objektu."""
print("Destruktor:", self._first_name, self._surname)
def test_destructor():
# vytvoření dvou instancí třídy
employee1 = Employee("Eda", "Wasserfall", 10000)
employee2 = Employee("Přemysl", "Hájek", 25001)
test_destructor()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Ukázka jednoduché třídy reprezentující zaměstnance."""
class Employee:
"""Třída reprezentující zaměstnance."""
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
print("Konstruktor:", first_name, surname)
self._first_name = first_name
self._surname = surname
self._salary = salary
def __del__(self):
"""Destruktor objektu."""
print("Destruktor:", self._first_name, self._surname)
# vytvoření dvou instancí třídy
employee1 = Employee("Eda", "Wasserfall", 10000)
employee2 = Employee("Přemysl", "Hájek", 25001)
print("Konec programu")
del#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Explicitní smazání objektu konstrukcí del."""
class Employee:
"""Třída reprezentující zaměstnance."""
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
print("Konstruktor:", first_name, surname)
self._first_name = first_name
self._surname = surname
self._salary = salary
def __del__(self):
"""Destruktor objektu."""
print("Destruktor:", self._first_name, self._surname)
def test_destructor():
# vytvoření dvou instancí třídy
employee1 = Employee("Eda", "Wasserfall", 10000)
employee2 = Employee("Přemysl", "Hájek", 25001)
test_destructor()
employee3 = Employee("x", "y", 0)
print("Volam del")
del employee3
print("Konec programu")
self def display_employee(self):
print("Full name: ", self._first_name, self._surname, " Salary: ", self._salary)
display_employee#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Ukázka jednoduché třídy reprezentující zaměstnance."""
class Employee:
"""Třída reprezentující zaměstnance."""
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
self._first_name = first_name
self._surname = surname
self._salary = salary
def display_employee(self):
"""Metoda pro výpis hodnoty objektu."""
print(
"Full name: ", self._first_name, self._surname, " Salary: ", self._salary
)
# vytvoření dvou instancí třídy
employee1 = Employee("Eda", "Wasserfall", 10000)
employee2 = Employee("Přemysl", "Hájek", 25001)
# výpis hodnot objektů
employee1.display_employee()
employee2.display_employee()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Vylepšení metody pro výpis hodnoty objektu."""
class Employee:
"""Třída reprezentující zaměstnance."""
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
self._first_name = first_name
self._surname = surname
self._salary = salary
def display_employee(self):
"""Metoda pro výpis hodnoty objektu."""
print(
"Full name: {name} {surname} Salary: {salary}".format(
name=self._first_name, surname=self._surname, salary=self._salary
)
)
# vytvoření dvou instancí třídy
employee1 = Employee("Eda", "Wasserfall", 10000)
employee2 = Employee("Přemysl", "Hájek", 25001)
# výpis hodnot objektů
employee1.display_employee()
employee2.display_employee()
–
__init__
__str__
__repr__
__hash__
__call__
__iter__
__getattr__
__getattribute__
__setattr__
__delattr__
__eq__ x, y x == y
__ne__ x, y x != y
__lt__ x, y x < y
__gt__ x, y x > y
__le__ x, y x <= y
__ge__ x, y x >= y
__add__ binární + operátor
__sub__ binární - operátor
__mul__ * operátor
__div__ / operátor
__floordiv__ // operátor (Python 2)
__truediv__ / operátor (Python 3)
__mod__ % operátor
__pow__ ** operátor or pow(x, y, z)
__neg__ unární - operátor
__pos__ unární + operátor
__abs__ absolutní hodnota
__nonzero__ konverze na Boolean
__invert__ ~ operátor
__lshift__ << operátor
__rshift__ >> operátor
__and__ & operátor
__or__ x, y | operátor
__xor__ ^ operátor
__iadd__ += operátor
__isub__ -= operátor
__imul__ *= operátor
__idiv__ /= operátor (Python 2)
__ifloordiv__ //= operátor
__itruediv__ /= operátor (Python 3)
__imod__ %= operátor
__ipow__ **= operátor
__ilshift__ <<= operátor
__irshift__ >>= operátor
__iand__ &= operátor
__ior__ |= operátor
__ixor__ ^= operátor
__str__#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Přetížení speciální metody pri převod objektu na řetězec."""
class Employee:
"""Třída reprezentující zaměstnance."""
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
self._first_name = first_name
self._surname = surname
self._salary = salary
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "Full name: {name} {surname} Salary: {salary}".format(
name=self._first_name, surname=self._surname, salary=self._salary
)
# vytvoření dvou instancí třídy
employee1 = Employee("Eda", "Wasserfall", 10000)
employee2 = Employee("Přemysl", "Hájek", 25001)
# výpis hodnot objektů
print(employee1)
print(employee2)
__eq__#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Přetížení speciální metody pro porovnání dvou objektů."""
class Employee:
"""Třída reprezentující zaměstnance."""
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
self._first_name = first_name
self._surname = surname
self._salary = salary
self._poznamka = 124
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "name: {name} {surname} Salary: {salary}".format(
name=self._first_name, surname=self._surname, salary=self._salary
)
def __eq__(self, other):
if other is None:
return False
return (
self._first_name == other._first_name
and self._surname == other._surname
and self._salary == other._salary
)
# vytvoření tří instancí třídy
employee1 = Employee("Eda", "Wasserfall", 10000)
employee2 = Employee("Eda", "Wasserfall", 10000)
employee3 = Employee("Přemysl", "Hájek", 25001)
# výpis hodnot objektů
print(employee1)
print(employee2)
print(employee1 == employee2)
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Třída představující komplexní čísla."""
class Complex:
"""Třída představující komplexní čísla."""
def __init__(self, real=0, imag=0):
"""Konstruktor."""
self._real = real
self._imag = imag
c1 = Complex(1, 2)
c2 = Complex(10, 20)
c3 = Complex(100)
c4 = Complex()
c5 = Complex(1, 2)
print(c1)
print(c2)
print(c3)
print(c4)
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Převod objektu na řetězec."""
class Complex:
def __init__(self, real=0, imag=0):
self._real = real
self._imag = imag
def __str__(self):
return "{r} + {i}j".format(r=self._real, i=self._imag)
c1 = Complex(1, 2)
c2 = Complex(10, 20)
c3 = Complex(100)
c4 = Complex()
c5 = Complex(1, 2)
print(c1)
print(c2)
print(c3)
print(c4)
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Porovnání komplexních čísel."""
class Complex:
def __init__(self, real=0, imag=0):
self._real = real
self._imag = imag
def __str__(self):
return "{r} + {i}j".format(r=self._real, i=self._imag)
def __eq__(self, other):
return self._real == other._real and self._imag == other._imag
c1 = Complex(1, 2)
c2 = Complex(10, 20)
c3 = Complex(100)
c4 = Complex()
c5 = Complex(1, 2)
print(c1)
print(c2)
print(c3)
print(c4)
print(c1 == c5)
print(c2 == c5)
print(c3 == c5)
+#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Součet komplexních čísel."""
class Complex:
def __init__(self, real=0, imag=0):
self._real = real
self._imag = imag
def __str__(self):
return "{r} + {i}j".format(r=self._real, i=self._imag)
def __eq__(self, other):
return self._real == other._real and self._imag == other._imag
def __add__(self, other):
r = self._real + other._real
i = self._imag + other._imag
return Complex(r, i)
c1 = Complex(1, 2)
c2 = Complex(10, 20)
c3 = Complex(100)
c4 = Complex()
c1 += c3
print(c1)
c5 = Complex(1, 2)
print(c1)
print(c2)
print(c3)
print(c4)
print(c1 == c5)
print(c2 == c5)
print(c3 == c5)
+=#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Přičtení komplexního čísla."""
class Complex:
def __init__(self, real=0, imag=0):
self._real = real
self._imag = imag
def __str__(self):
return "{r} + {i}j".format(r=self._real, i=self._imag)
def __eq__(self, other):
return self._real == other._real and self._imag == other._imag
def __add__(self, other):
r = self._real + other._real
i = self._imag + other._imag
return Complex(r, i)
def __iadd__(self, other):
self._real += other._real
self._imag += other._imag
return self
c1 = Complex(1, 2)
c2 = Complex(10, 20)
c3 = Complex(100)
c4 = Complex()
c1 += c3
print(c1)
c5 = Complex(1, 2)
print(c1)
print(c2)
print(c3)
print(c4)
print(c1 == c5)
print(c2 == c5)
print(c3 == c5)
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Negace komplexního čísla."""
class Complex:
def __init__(self, real=0, imag=0):
self._real = real
self._imag = imag
def __str__(self):
return "{r} + {i}j".format(r=self._real, i=self._imag)
def __eq__(self, other):
return self._real == other._real and self._imag == other._imag
def __add__(self, other):
r = self._real + other._real
i = self._imag + other._imag
return Complex(r, i)
def __iadd__(self, other):
self._real += other._real
self._imag += other._imag
return self
def __neg__(self):
r = self._real
i = self._imag
return Complex(-r, -i)
c1 = Complex(1, 2)
c2 = Complex(10, 20)
c3 = Complex(100)
c4 = Complex()
c1 += c3
print(c1)
c5 = Complex(1, 2)
print(c1)
print(c2)
print(c3)
print(c4)
print(c1 == c5)
print(c2 == c5)
print(c3 == c5)
c6 = -c1
print(c1)
print(c6)
__repr__#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Metoda __repr__."""
class Complex:
"""Třída představující komplexní čísla."""
def __init__(self, real=0, imag=0):
"""Konstruktor."""
self._real = real
self._imag = imag
def __str__(self):
return "{r} + {i}j".format(r=self._real, i=self._imag)
def __repr__(self):
return "Complex({r}, {i})".format(r=self._real, i=self._imag)
def __eq__(self, other):
return self._real == other._real and self._imag == other._imag
def __add__(self, other):
r = self._real + other._real
i = self._imag + other._imag
return Complex(r, i)
def __iadd__(self, other):
self._real += other._real
self._imag += other._imag
return self
def __neg__(self):
r = self._real
i = self._imag
return Complex(-r, -i)
c1 = Complex(1, 2)
c2 = Complex(10, 20)
c3 = c1 + c2
print(c3)
print(c3)
print(c3.__repr__())
Vybrané vlastnosti je možné modifikovat
Person a od ní odvozená třída Student#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Třída Person a odvození třídy Student."""
class Person:
def __init__(self, first_name, surname):
"""Konstruktor objektu."""
self._first_name = first_name
self._surname = surname
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Person** Full name: {name} {surname}".format(
name=self._first_name, surname=self._surname
)
class Student(Person):
pass
# vytvoření dvou instancí třídy
p1 = Person("Eda", "Wasserfall")
p2 = Person("Přemysl", "Hájek")
print(p1)
print(p2)
s1 = Student("John", "Doe")
print(s1)
__str__ ve třídě Student#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Přetížení metody __str__ ve třídě Student."""
class Person:
def __init__(self, first_name, surname):
"""Konstruktor objektu."""
self._first_name = first_name
self._surname = surname
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Person** Full name: {name} {surname}".format(
name=self._first_name, surname=self._surname
)
class Student(Person):
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Student** Full name: {name} {surname}".format(
name=self._first_name, surname=self._surname
)
# vytvoření dvou instancí třídy
p1 = Person("Eda", "Wasserfall")
p2 = Person("Přemysl", "Hájek")
print(p1)
print(p2)
s1 = Student("John", "Doe")
print(s1)
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Volání konstruktoru nadtřídy."""
class Person:
def __init__(self, first_name, surname):
"""Konstruktor objektu."""
self._first_name = first_name
self._surname = surname
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Person** Full name: {name} {surname}".format(
name=self._first_name, surname=self._surname
)
class Student(Person):
def __init__(self, first_name, surname):
"""Konstruktor objektu."""
super().__init__(first_name, surname)
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Student** Full name: {name} {surname}".format(
name=self._first_name, surname=self._surname
)
# vytvoření dvou instancí třídy
p1 = Person("Eda", "Wasserfall")
p2 = Person("Přemysl", "Hájek")
print(p1)
print(p2)
s1 = Student("John", "Doe")
print(s1)
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Volání konstruktoru nadtřídy, rozlišení konstruktorů."""
class Person:
def __init__(self, first_name, surname):
"""Konstruktor objektu."""
print("Person.__init__")
self._first_name = first_name
self._surname = surname
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Person** Full name: {name} {surname}".format(
name=self._first_name, surname=self._surname
)
class Student(Person):
def __init__(self, first_name, surname):
"""Konstruktor objektu."""
print("Student.__init__")
super().__init__(first_name, surname)
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Student** Full name: {name} {surname}".format(
name=self._first_name, surname=self._surname
)
# vytvoření dvou instancí třídy
p1 = Person("Eda", "Wasserfall")
p2 = Person("Přemysl", "Hájek")
print(p1)
print(p2)
s1 = Student("John", "Doe")
print(s1)
Employee odvozená od třídy Person#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Další třída Employee odvozená od třídy Person."""
class Person:
def __init__(self, first_name, surname):
"""Konstruktor objektu."""
print("Person.__init__")
self._first_name = first_name
self._surname = surname
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Person** Full name: {name} {surname}".format(
name=self._first_name, surname=self._surname
)
class Student(Person):
def __init__(self, first_name, surname):
"""Konstruktor objektu."""
print("Student.__init__")
super().__init__(first_name, surname)
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Student** Full name: {name} {surname}".format(
name=self._first_name, surname=self._surname
)
class Employee(Person):
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
print("Employee.__init__")
super().__init__(first_name, surname)
self._salary = salary
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Employee** Full name: {name} {surname} Salary: {salary}".format(
name=self._first_name, surname=self._surname, salary=self._salary
)
# vytvoření dvou instancí třídy
p1 = Person("Eda", "Wasserfall")
p2 = Person("Přemysl", "Hájek")
print(p1)
print(p2)
s1 = Student("John", "Doe")
print(s1)
e1 = Employee("Eric", "Iverson", 10000)
print(e1)
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Ukázka polymorfismu."""
class Person:
def __init__(self, first_name, surname):
"""Konstruktor objektu."""
print("Person.__init__")
self._first_name = first_name
self._surname = surname
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Person** Full name: {name} {surname}".format(
name=self._first_name, surname=self._surname
)
class Student(Person):
def __init__(self, first_name, surname):
"""Konstruktor objektu."""
print("Student.__init__")
super().__init__(first_name, surname)
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Student** Full name: {name} {surname}".format(
name=self._first_name, surname=self._surname
)
class Employee(Person):
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
print("Employee.__init__")
super().__init__(first_name, surname)
self._salary = salary
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Employee** Full name: {name} {surname} Salary: {salary}".format(
name=self._first_name, surname=self._surname, salary=self._salary
)
people = [
Person("Eda", "Wasserfall"),
Person("Přemysl", "Hájek"),
Student("John", "Doe"),
Employee("Eric", "Iverson", 10000),
]
for p in people:
print(p)
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Ukázka polymorfismu (třída jako rozhraní)."""
class Printable:
def display(self):
print(self)
class Person(Printable):
def __init__(self, first_name, surname):
"""Konstruktor objektu."""
print("Person.__init__")
self._first_name = first_name
self._surname = surname
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Person** Full name: {name} {surname}".format(
name=self._first_name, surname=self._surname
)
class Student(Person):
def __init__(self, first_name, surname):
"""Konstruktor objektu."""
print("Student.__init__")
super().__init__(first_name, surname)
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Student** Full name: {name} {surname}".format(
name=self._first_name, surname=self._surname
)
class Employee(Person):
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
print("Employee.__init__")
super().__init__(first_name, surname)
self._salary = salary
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Employee** Full name: {name} {surname} Salary: {salary}".format(
name=self._first_name, surname=self._surname, salary=self._salary
)
people = [
Person("Eda", "Wasserfall"),
Person("Přemysl", "Hájek"),
Student("John", "Doe"),
Employee("Eric", "Iverson", 10000),
]
for p in people:
p.display()
class Person:
def __init__(self, first_name, surname):
"""Konstruktor objektu."""
print("Person.__init__")
self._first_name = first_name
self._surname = surname
def get_name(self):
return "Person: {} {}".format(self._first_name, self._surname)
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Person** Full name: {name} {surname}".format(
name=self._first_name, surname=self._surname
)
class Student(Person):
def __init__(self, first_name, surname):
"""Konstruktor objektu."""
print("Student.__init__")
super().__init__(first_name, surname)
def get_name(self):
return "Student: {} {}".format(self._first_name, self._surname)
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Student** Full name: {name} {surname}".format(
name=self._first_name, surname=self._surname
)
class Employee(Person):
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
print("Employee.__init__")
super().__init__(first_name, surname)
self._salary = salary
def get_name(self):
return "Employee: {} {}".format(self._first_name, self._surname)
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Employee** Full name: {name} {surname} Salary: {salary}".format(
name=self._first_name, surname=self._surname, salary=self._salary
)
people = [
Person("Eda", "Wasserfall"),
Person("Přemysl", "Hájek"),
Student("John", "Doe"),
Employee("Eric", "Iverson", 10000),
]
for p in people:
print(p.get_name())
class Person:
def __init__(self, first_name, surname):
"""Konstruktor objektu."""
print("Person.__init__")
self._first_name = first_name
self._surname = surname
def get_name(self):
return "Person: {} {}".format(self._first_name, self._surname)
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Person** Full name: {name} {surname}".format(
name=self._first_name, surname=self._surname
)
class Student(Person):
def __init__(self, first_name, surname):
"""Konstruktor objektu."""
print("Student.__init__")
super().__init__(first_name, surname)
def get_name(self):
return "Student: {} {}".format(self._first_name, self._surname)
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Student** Full name: {name} {surname}".format(
name=self._first_name, surname=self._surname
)
class Employee(Person):
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
print("Employee.__init__")
super().__init__(first_name, surname)
self._salary = salary
def calc_bonus(self):
return self._salary * 0.5
def get_name(self):
return "Employee: {} {}".format(self._first_name, self._surname)
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "**Employee** Full name: {name} {surname} Salary: {salary}".format(
name=self._first_name, surname=self._surname, salary=self._salary
)
class Manager(Employee):
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
print("Manager.__init__")
super().__init__(first_name, surname, salary)
def calc_bonus(self):
return self._salary * 0.75
e1 = Employee("Eric", "Iverson", 10000)
m1 = Manager("aaa", "bbb", 10000)
print(e1.calc_bonus())
print(m1.calc_bonus())
Parametr cls (jako class) nikoli self
class CLS:
x = 10
c1 = CLS()
print(CLS.x)
print(c1.x)
c1.x = 20
print(CLS.x)
print(c1.x)
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Metoda třídy."""
class Employee:
"""Třída reprezentující zaměstnance."""
counter = 0
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
self._first_name = first_name
self._surname = surname
self._salary = salary
Employee.inc_counter()
def display_employee(self):
"""Metoda pro výpis hodnoty objektu."""
print(
"Full name: {name} {surname} Salary: {salary}".format(
name=self._first_name, surname=self._surname, salary=self._salary
)
)
@classmethod
def inc_counter(cls):
cls.counter += 1
@classmethod
def num_employees(cls):
return cls.counter
# vytvoření dvou instancí třídy
employee1 = Employee("Eda", "Wasserfall", 10000)
print("Now we have", Employee.num_employees(), "employees")
employee2 = Employee("Přemysl", "Hájek", 25001)
print("Now we have", Employee.num_employees(), "employees")
# výpis hodnot objektů
employee1.display_employee()
employee2.display_employee()
I proto nemají parametr self
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Statická metoda."""
class Employee:
"""Třída reprezentující zaměstnance."""
counter = 0
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
self._first_name = first_name
self._surname = surname
self._salary = salary
Employee.inc_counter()
Employee.dec_counter()
def display_employee(self):
"""Metoda pro výpis hodnoty objektu."""
print(
"Full name: {name} {surname} Salary: {salary}".format(
name=self._first_name, surname=self._surname, salary=self._salary
)
)
@classmethod
def inc_counter(cls):
cls.counter += 1
@staticmethod
def dec_counter():
# !!!
cls.counter += 1
@classmethod
def num_employees(cls):
return cls.counter
# vytvoření dvou instancí třídy
employee1 = Employee("Eda", "Wasserfall", 10000)
print("Now we have", Employee.num_employees(), "employees")
employee2 = Employee("Přemysl", "Hájek", 25001)
print("Now we have", Employee.num_employees(), "employees")
# výpis hodnot objektů
employee1.display_employee()
employee2.display_employee()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Statická metoda."""
class Employee:
"""Třída reprezentující zaměstnance."""
counter = 0
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
self._first_name = first_name
self._surname = surname
self._salary = salary
Employee.inc_counter()
def display_employee(self):
"""Metoda pro výpis hodnoty objektu."""
print(
"Full name: {name} {surname} Salary: {salary}".format(
name=self._first_name, surname=self._surname, salary=self._salary
)
)
@classmethod
def inc_counter(cls):
cls.counter += 1
if Employee.too_much(cls.counter):
raise Exception("Company is full!")
@staticmethod
def too_much(cnt):
return cnt > 3
@classmethod
def num_employees(cls):
return cls.counter
# vytvoření dvou instancí třídy
employee1 = Employee("Eda", "Wasserfall", 10000)
print("Now we have", Employee.num_employees(), "employees")
employee2 = Employee("Přemysl", "Hájek", 25001)
print("Now we have", Employee.num_employees(), "employees")
# výpis hodnot objektů
employee1.display_employee()
employee2.display_employee()
e3 = Employee("Foo", "Bar", 0)
e4 = Employee("Foo", "Baz", 0)
–
map atd.)returnf = lambda x, y: x + y
print(f(1, 2))
f = lambda: "hello"
print(f())
f = lambda _: "hello"
print(f("foo"))
def calculate(what, x, y):
return what(x, y)
def add(x, y):
return x + y
result = calculate(add, 10, 20)
print(result)
def calculate(what, x, y):
return what(x, y)
def add(x, y):
return x + y
def get_function(selector):
if selector == "add":
return add
return None
adder = get_function("add")
result = calculate(adder, 10, 20)
print(result)
def increment_by(n):
def add(x):
return x + n
return add
i1 = increment_by(2)
print(i1(1))
print(i1(10))
i2 = increment_by(100)
print(i2(1))
print(i2(10))
Nutnost použití modifikátoru nonlocal
Typický příklad - libovolné množství čítačů
def counter():
cnt = 0
def impl():
nonlocal cnt
cnt += 1
return cnt
return impl
c1 = counter()
c2 = counter()
print(c1())
print(c1())
print(c1())
print(c2())
print(c1())
print(c1())
print(c1())
print(c2())
(lze implementovat i s využitím generátorů)
Další příklady
def increment_by(n):
return lambda x: x + n
def add(x):
return x + x
i1 = increment_by(2)
print(i1(1))
print(i1(10))
i2 = increment_by(100)
print(i2(1))
print(i2(10))
print(add)
print(i1)
print(i2)
def counter(start=0, step=1):
cnt = start
def impl():
nonlocal cnt
cnt += step
return cnt
return impl
c1 = counter(10, 1)
c2 = counter(0, 2)
c3 = counter(100, -10)
for i in range(10):
print("c1", c1())
print()
for i in range(10):
print("c2", c2())
print()
for i in range(10):
print("c3", c3())
append"""Generátorová notace seznamu."""
seznam = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
seznam1 = [item for item in seznam]
seznam2 = [item * 2 for item in seznam]
seznam3 = [item for item in seznam if item % 3 == 0]
print(seznam)
print(seznam1)
print(seznam2)
print(seznam3)
seznam = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(seznam)
seznam2 = []
for item in seznam:
seznam2.append(item * 2)
print(seznam2)
seznam = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(seznam)
seznam3 = []
for item in seznam:
if item % 3 == 0:
seznam3.append(item)
print(seznam3)
seznam3B = [item for item in seznam if item % 3 == 0]
print(seznam3B)
mapreducefiltermap
lambda#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Funkce vyššího řádu map."""
x = range(10)
print(x)
y = map(lambda value: value * 2, x)
print(list(y))
- popř. s pojmenovanou funkcí
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Funkce vyššího řádu map."""
def inc(x):
return x + 1
x = range(10)
print(x)
y = map(inc, x)
print(list(y))
filter
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Funkce vyššího řádu filter."""
x = range(20)
print(x)
y = filter(lambda value: value % 3 == 0, x)
print(list(y))
reduce
functools#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Funkce vyššího řádu reduce."""
from functools import reduce
x = range(1, 11)
print(x)
y = reduce(lambda a, b: a * b, x)
print(y)
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Funkce vyššího řádu reduce."""
from functools import reduce
x = range(1, 101)
print(x)
y = reduce(lambda a, b: a + b, x)
print(y)
reduce#!/usr/bin/env python
# encoding=utf-8
"""Výpočet faktoriálu pomocí reduce."""
from functools import reduce
def factorial(n):
"""Výpočet faktoriálu pomocí reduce."""
return reduce(lambda a, b: a * b, range(1, n + 1))
# výpočet 10!
print(factorial(10))
# tabulka s hodnotami n!
for n in range(1, 11):
print(n, factorial(n))
x and y - pokud x==False, není nutné vyhodnotit yx or y - pokud x==True, není nutné vyhodnotit y#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Zkrácené vyhodnocení logických operátorů."""
def x():
print("x() called")
return False
def y():
print("y() called")
return False
if x() or y():
print("if branch")
else:
print("else branch")
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Zkrácené vyhodnocení logických operátorů."""
def x():
print("x() called")
return True
def y():
print("y() called")
return False
if x() or y():
print("if branch")
else:
print("else branch")
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Zkrácené vyhodnocení logických operátorů."""
def x():
print("x() called")
return False
def y():
print("y() called")
return True
if x() or y():
print("if branch")
else:
print("else branch")
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Zkrácené vyhodnocení logických operátorů."""
def x():
print("x() called")
return True
def y():
print("y() called")
return True
if x() or y():
print("if branch")
else:
print("else branch")
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Zkrácené vyhodnocení logických operátorů."""
def x():
print("x() called")
return False
def y():
print("y() called")
return False
if x() and y():
print("if branch")
else:
print("else branch")
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Zkrácené vyhodnocení logických operátorů."""
def x():
print("x() called")
return True
def y():
print("y() called")
return False
if x() and y():
print("if branch")
else:
print("else branch")
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Zkrácené vyhodnocení logických operátorů."""
def x():
print("x() called")
return False
def y():
print("y() called")
return True
if x() and y():
print("if branch")
else:
print("else branch")
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Zkrácené vyhodnocení logických operátorů."""
def x():
print("x() called")
return True
def y():
print("y() called")
return True
if x() and y():
print("if branch")
else:
print("else branch")
–
def n_items(max_n):
n, numbers = 0, []
while n <= max_n:
numbers.append(n)
n += 1
return numbers
lst = n_items(20)
print(lst)
def generator(max_n):
n = 0
while n < max_n:
yield n
n += 1
for i in generator(10000):
print(i)
if i >= 10:
break
def infinite_generator():
n = 0
while True:
yield n
n += 1
for i in infinite_generator():
print(i)
if i >= 10:
break
class generator:
def __init__(self, max_n):
self.max_n = max_n
self.n = 0
def __iter__(self):
return self
def __next__(self):
if self.n < self.max_n:
current, self.n = self.n, self.n + 1
return current
raise StopIteration()
for i in generator(10000):
print(i)
if i >= 10:
break
class infinite_generator:
def __init__(self):
self.n = 0
def __iter__(self):
return self
def __next__(self):
current, self.n = self.n, self.n + 1
return current
for i in infinite_generator():
print(i)
if i >= 10:
break
#!/usr/bin/env python
# encoding=utf-8
seznam = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
g1 = (item for item in seznam)
g2 = (item * 2 for item in seznam)
g3 = (item for item in seznam if item % 3 == 0)
print(seznam)
print(g1)
print(g2)
print(g3)
#!/usr/bin/env python
# encoding=utf-8
seznam = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
g1 = list(item for item in seznam)
g2 = list(item * 2 for item in seznam)
g3 = list(item for item in seznam if item % 3 == 0)
print(seznam)
print(g1)
print(g2)
print(g3)
def function_caller(function):
def inner_function():
print("Calling function...")
function()
print("...done")
return inner_function
def hello():
print("Hello!")
f = function_caller(hello)
f()
def function_caller(function):
def inner_function():
print("Calling function...")
function()
print("...done")
return inner_function
@function_caller
def hello():
print("Hello!")
hello()
# Original code:
# https://pythonbasics.org/decorators/#Real-world-examples
import time
def measure_time(func):
def wrapper(*arg):
t = time.time()
res = func(*arg)
print("Function took " + str(time.time() - t) + " seconds to run")
return res
return wrapper
@measure_time
def tested_function(n):
time.sleep(n)
tested_function(1)
tested_function(2)
def hello():
print("Hello!")
hello()
def wrapper1(function):
def inner_function():
print("-" * 40)
function()
print("-" * 40)
return inner_function
@wrapper1
def hello():
print("Hello!")
hello()
def wrapper1(function):
def inner_function():
print("-" * 40)
function()
print("-" * 40)
return inner_function
def wrapper2(function):
def inner_function():
print("=" * 40)
function()
print("=" * 40)
return inner_function
@wrapper1
@wrapper2
def hello():
print("Hello!")
hello()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Gettery a settery."""
class Employee:
"""Třída reprezentující zaměstnance."""
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
self._first_name = first_name
self._surname = surname
self._salary = salary
self._poznamka = 124
self._age = None
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "name: {name} {surname} Salary: {salary} Age: {age}".format(
name=self._first_name,
surname=self._surname,
salary=self._salary,
age=self._age,
)
def set_age(self, age):
if age <= 0:
raise ValueError("The age must be positive")
self._age = age
def get_age(self):
return self._age
# vytvoření tří instancí třídy
employee1 = Employee("Eda", "Wasserfall", 10000)
employee2 = Employee("Eda", "Wasserfall", 10000)
employee1.set_age(30)
employee2.set_age(40)
# výpis hodnot objektů
print(employee1)
print(employee2)
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Properties."""
class Employee:
"""Třída reprezentující zaměstnance."""
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
self._first_name = first_name
self._surname = surname
self._salary = salary
self._poznamka = 124
self._age = None
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "name: {name} {surname} Salary: {salary} Age: {age}".format(
name=self._first_name,
surname=self._surname,
salary=self._salary,
age=self._age,
)
def set_age(self, age):
if age <= 0:
raise ValueError("The age must be positive")
self._age = age
def get_age(self):
return self._age
age = property(fget=get_age, fset=set_age)
# vytvoření tří instancí třídy
employee1 = Employee("Eda", "Wasserfall", 10000)
employee2 = Employee("Eda", "Wasserfall", 10000)
employee1.age = 30
employee2.age = 40
# výpis hodnot objektů
print(employee1)
print(employee2)
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Properties."""
class Employee:
"""Třída reprezentující zaměstnance."""
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
self._first_name = first_name
self._surname = surname
self._salary = salary
self._poznamka = 124
self._age = None
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "name: {name} {surname} Salary: {salary} Age: {age}".format(
name=self._first_name,
surname=self._surname,
salary=self._salary,
age=self._age,
)
@property
def age(self):
return self._age
@age.setter
def age(self, age):
if age <= 0:
raise ValueError("The age must be positive")
self._age = age
# vytvoření tří instancí třídy
employee1 = Employee("Eda", "Wasserfall", 10000)
employee2 = Employee("Eda", "Wasserfall", 10000)
employee1.age = 30
employee2.age = 40
# výpis hodnot objektů
print(employee1)
print(employee2)
–
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
if __name__ == "__main__":
main()
sys.argv
len(sys.argv) pro počet předaných parametrůargparseargparse#!/usr/bin/env python3
from argparse import ArgumentParser
def cli_arguments():
"""Retrieve all CLI arguments provided by user."""
# First of all, we need to specify all command line flags that are
# recognized by this tool.
parser = ArgumentParser()
# All supported command line arguments and flags
parser.add_argument(
"-a",
"--address",
dest="address",
required=False,
help="Address of REST API for external data pipeline",
)
parser.add_argument(
"-u",
"--user",
dest="user",
required=False,
help="User name for basic authentication",
)
parser.add_argument(
"-p",
"--password",
dest="password",
required=False,
help="Password for basic authentication",
)
parser.add_argument(
"-i",
"--input",
dest="input",
default=None,
required=False,
help="Specification of input file (with list of clusters, for example)",
)
parser.add_argument(
"-c",
"--compare-results",
dest="compare_results",
action="store_true",
default=None,
required=False,
help="Compare two sets of results, each set stored in its own directory",
)
parser.add_argument(
"-e",
"--export",
dest="export_file_name",
required=False,
default="report.csv",
help="Name of CSV file with exported comparison results",
)
parser.add_argument(
"-v",
"--verbose",
dest="verbose",
action="store_true",
default=None,
help="Make messages verbose",
required=False,
)
# Now it is time to parse flags, check the actual content of command line
# and fill-in the object named `args`.
return parser.parse_args()
def main():
"""Entry point to this script."""
# Parse and process and command line arguments.
args = cli_arguments()
# Verbosity flag
verbose = args.verbose
# If this script is started from command line, run the `main` function which is
# entry point to the processing.
if __name__ == "__main__":
main()
–
fout = open("data.txt", "w")
for i in range(1, 11):
fout.write(str(i) + "\n")
fout.close()
fout = open("data.txt", "a")
for i in range(1, 11):
fout.write(str(i) + "\n")
fout.close()
for znak in range(ord("a"), ord("z") + 1):
print(chr(znak))
stringprint("hodnota: {value:5d}".format(value=42))
print("hodnota: {value:05d}".format(value=42))
for x in range(1, 11):
y = 1.0/x
print("1/{x:2d} = {y:5.3f}".format(x=x, y=y))
for x in range(1, 11):
y = 1.0/x
print("1/{x:02d} = {y:5.3f}".format(x=x, y=y))
for x in range(1, 11):
y = 1.0/x
print("1/{x:<2d} = {y:5.3f}".format(x=x, y=y))
splitx = "prvni,druhy,treti,ctvrty"
l = x.split(",")
joinl = ["prvni", "druhy", "treti", "ctvrty"]
x = ",".join(l)
replace"vccvxvcxz".replace("c", "-")
'v--vxv-xz'
re* sekvence 0..n atomů+ sekvence 1..n atomů? žádný nebo jeden atom{m} v závorce je zapsán přesný počet atomů{m,} v závorce je zapsán minimální počet atomů{m,n} v závorce je minimální a maximální počet atomůx konkrétní znak() prázdný řetězec. jediný znak\X řídicí znak či znak se zadaným kódem(xxx) část výrazu, k níž lze později přistupovat (podle indexu)^ nahrazuje začátek řádku$ nahrazuje konec řádku- se určuje rozsah a-z, 5-7 atd.^ negace - všechny znaky, které NEodpovídají dalšímu výrazu[] změní třídu znaků na množinu\a alert (bell)\b backspace\B může se použít namísto \\ (čitelnější)\e znak ESCape\n nový řádek\r návrat kurzoru\t tab\u1234 znak se zadaným Unikódem\d [[:digit:]]\s [[:space:]]\w [[:alnum:]_] jako \d a _\D [^[:digit:]]\S [^[:space:]]\W [^[:alnum:]_] negace \W"(\[0-9]{1,3})\.(\[0-9]{1,3})\.(\[0-9]{1,3})\.(\[0-9]{1,3})""[-+]?([0-9]+\.?[0-9]*|\.[0-9]+)([eE][-+]?[0-9]+)?"import subprocess
import re
def get_framebuffer_resolution(framebuffer_device):
fbset_output = subprocess.check_output(["fbset", "-s", "-fb", framebuffer_device])
for line in fbset_output.split("\n"):
line = line.strip()
if line.startswith("geometry"):
print(line)
parsed = re.match(r"geometry (\d+) (\d+)", line)
return (parsed.group(1), parsed.group(2))
print(get_framebuffer_resolution("/dev/fb0"))
import subprocess
import re
def get_framebuffer_resolution(framebuffer_device):
fbset_output = subprocess.check_output(["fbset", "-s", "-fb", framebuffer_device])
regexp = re.compile(r"geometry (\d+) (\d+)")
for line in fbset_output.split("\n"):
line = line.strip()
if line.startswith("geometry"):
print(line)
parsed = regexp.match(line)
return (parsed.group(1), parsed.group(2))
print(get_framebuffer_resolution("/dev/fb0"))
HTTP_RE = re.compile(
r"^(?:https://[^/]+\.s3\.amazonaws\.com/[0-9a-zA-Z/\-]+|"
r"https://s3\.[0-9a-zA-Z\-]+\.amazonaws\.com/[0-9a-zA-Z\-]+/[0-9a-zA-Z/\-]+|"
r"http://minio:9000/insights-upload-perma/[0-9a-zA-Z\.\-]+/[0-9a-zA-Z\-]+)\?"
r"X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=[^/]+$"
)
def get(self, src):
"""Download a file from HTTP server and store it in a temporary file."""
if src is None or not HTTP_RE.fullmatch(src):
raise DataPipelineError(f"Invalid URL format: {src}")
datetimedatetime.datedatetime.timedatetime.datetimedatetime.timedeltaimport datetime
dt = datetime.datetime.now()
print(dt)
s = dt.strftime("%Y-%m-%d")
print(s)
s = dt.strftime("%d.%m.%Y")
print(s)
s = dt.strftime("%m/%d/%Y")
print(s)
s = dt.strftime("%H:%m:%S")
print(s)
import datetime
s = "2021-11-12"
dt = datetime.datetime.strptime(s, "%Y-%m-%d")
print(dt)
s = "2021-11-12 10:20:30"
dt = datetime.datetime.strptime(s, "%Y-%m-%d %H:%M:%S")
print(dt)
s = "10:20:30"
dt = datetime.datetime.strptime(s, "%H:%M:%S")
print(dt)
pprintpprint.PrettyPrinter
indent=1width=80depth=NonePrettyPrinter.formatpprint.pprintarrayPaměťově efektivní uložení prvků v polích
Podporované typy prvků
'b' signed char int 1
'B' unsigned char int 1
'u' wchar_t Unicode character 2
'h' signed short int 2
'H' unsigned short int 2
'i' signed int int 2 (4)
'I' unsigned int int 2 (4)
'l' signed long int 4 (8)
'L' unsigned long int 4 (8)
'q' signed long long int 8 (16)
'Q' unsigned long long int 8 (16)
'f' float float 4
'd' double float 8
#!/usr/bin/env python3
"""Základní způsob použití modulu `array`."""
from array import array
a1 = array("l")
a2 = array("u", "hello \u2567")
a3 = array("l", [1, 2, 3, 4, 5])
a4 = array("d", [1.0, 2.0, 3.14])
print(a1)
print(a2)
print(a3)
print(a4)
a3[3] = -1
print(a3)
#!/usr/bin/env python3
"""Základní způsob použití modulu `array` - celočíselné typy."""
from array import array
input_data = [i for i in range(0, 10)]
a1 = array("b", input_data)
a2 = array("B", input_data)
a3 = array("h", input_data)
a4 = array("H", input_data)
a5 = array("i", input_data)
a6 = array("I", input_data)
a7 = array("l", input_data)
a8 = array("L", input_data)
print(a1)
print(a2)
print(a3)
print(a4)
print(a5)
print(a6)
print(a7)
print(a8)
print(a1.buffer_info()[1] * a1.itemsize)
print(a2.buffer_info()[1] * a2.itemsize)
print(a3.buffer_info()[1] * a3.itemsize)
print(a4.buffer_info()[1] * a4.itemsize)
print(a5.buffer_info()[1] * a5.itemsize)
print(a6.buffer_info()[1] * a6.itemsize)
print(a7.buffer_info()[1] * a7.itemsize)
print(a8.buffer_info()[1] * a8.itemsize)
#!/usr/bin/env python3
"""Základní způsob použití modulu `array` - zápis polí do souboru."""
from array import array
a1 = array("l")
a2 = array("u", "hello \u2567")
a3 = array("l", [1, 2, 3, 4, 5])
a4 = array("d", [1.0, 2.0, 3.14])
with open("a1", "wb") as fout:
a1.tofile(fout)
with open("a2", "wb") as fout:
a2.tofile(fout)
with open("a3", "wb") as fout:
a3.tofile(fout)
with open("a4", "wb") as fout:
a4.tofile(fout)
#!/usr/bin/env python3
"""Základní způsob použití modulu `array` - čtení polí ze souboru."""
from array import array
a1 = array("l")
a2 = array("u")
a3 = array("l")
a4 = array("d")
with open("a1", "rb") as fin:
a1.fromfile(fin, 0)
with open("a2", "rb") as fin:
a2.fromfile(fin, 5)
with open("a3", "rb") as fin:
a3.fromfile(fin, 5)
with open("a4", "rb") as fin:
a4.fromfile(fin, 3)
print(a1)
print(a2)
print(a3)
print(a4)
print(a1.buffer_info()[1] * a1.itemsize)
print(a2.buffer_info()[1] * a2.itemsize)
print(a3.buffer_info()[1] * a3.itemsize)
print(a4.buffer_info()[1] * a4.itemsize)
queuequeue.Queue
queue.SimpleQueue
queue.LifoQueue
queue.PriorityQueue
qsizeemptyfullputput_nowaitgetget_nowaitjoin#!/usr/bin/env python3
import queue
q = queue.Queue(500)
for item in range(10):
print("Size", q.qsize())
print("Empty?", q.empty())
print("Full?", q.full())
q.put("prvek # {}".format(item))
while not q.empty():
print("Read item:", q.get())
#!/usr/bin/env python3
import queue
q = queue.SimpleQueue()
for item in range(10):
print("Size", q.qsize())
print("Empty?", q.empty())
print("Full?", q.full())
q.put("prvek # {}".format(item))
while not q.empty():
print("Read item:", q.get())
#!/usr/bin/env python3
import queue
q = queue.LifoQueue(500)
for item in range(10):
print("Size", q.qsize())
print("Empty?", q.empty())
print("Full?", q.full())
q.put("prvek # {}".format(item))
while not q.empty():
print("Read item:", q.get())
#!/usr/bin/env python3
import queue
import random
q = queue.PriorityQueue(40)
for item in range(30):
print("Size", q.qsize())
print("Empty?", q.empty())
print("Full?", q.full())
value = random.randint(1, 20)
print(value)
q.put("prvek # {:2d}".format(value))
while not q.empty():
print("Read item:", q.get())
import time
import threading
import queue
# vytvoření fronty
q = queue.Queue()
# simulace konzumenta
def consumer():
while True:
job = q.get()
print(f"Starting consuming {job}")
time.sleep(0.4)
print(f"Consumed {job}")
q.task_done()
# spuštění konzumenta
threading.Thread(target=consumer, daemon=True, name="první").start()
# vytvoření úloh v producentovi
for job in range(10):
print(f"Producing {job}")
q.put(job)
# čekání na zpracování všech zpráv ve frontě
q.join()
print("Done")
import time
import threading
import queue
# vytvoření fronty
q = queue.Queue()
# simulace konzumenta
def consumer():
name = threading.current_thread().name
while True:
job = q.get()
print(f"{name} thread: Starting consuming {job}")
time.sleep(0.4)
print(f"{name} thread: Consumed {job}")
q.task_done()
# spuštění konzumentů
threading.Thread(target=consumer, daemon=True, name="1st").start()
threading.Thread(target=consumer, daemon=True, name="2nd").start()
threading.Thread(target=consumer, daemon=True, name="3rd").start()
# vytvoření úloh v producentovi
for job in range(10):
print(f"Producing {job}")
q.put(job)
# čekání na zpracování všech zpráv ve frontě
q.join()
print("Done")
import time
import threading
import queue
# vytvoření fronty
q = queue.Queue()
# simulace producenta
def producer():
name = threading.current_thread().name
for job in range(10):
print(f"{name} thread: Starting producing {job}")
q.put(job)
time.sleep(0.3)
print(f"{name} thread: Produced {job}")
# simulace konzumenta
def consumer():
name = threading.current_thread().name
while True:
job = q.get()
print(f"{name} thread: Starting consuming {job}")
time.sleep(0.4)
print(f"{name} thread: Consumed {job}")
q.task_done()
# spuštění konzumentů
threading.Thread(target=consumer, daemon=True, name="1st").start()
threading.Thread(target=consumer, daemon=True, name="2nd").start()
threading.Thread(target=consumer, daemon=True, name="3rd").start()
# spuštění producentů
threading.Thread(target=producer, daemon=True, name="1st").start()
threading.Thread(target=producer, daemon=True, name="2nd").start()
threading.Thread(target=producer, daemon=True, name="3rd").start()
threading.Thread(target=producer, daemon=True, name="3rd").start()
# čekání na zpracování všech zpráv ve frontě
q.join()
print("Done")
import time
import threading
import queue
# vytvoření fronty
q = queue.Queue()
# simulace producenta
def producer():
name = threading.current_thread().name
for job in range(1000):
print(f"{name} thread: Starting producing {job}")
q.put(job)
time.sleep(0.3)
print(f"{name} thread: Produced {job}")
# simulace konzumenta
def consumer():
name = threading.current_thread().name
while True:
job = q.get()
print(f"{name} thread: Starting consuming {job}")
time.sleep(0.4)
print(f"{name} thread: Consumed {job}")
q.task_done()
# spuštění konzumentů
threading.Thread(target=consumer, daemon=True, name="1st").start()
threading.Thread(target=consumer, daemon=True, name="2nd").start()
threading.Thread(target=consumer, daemon=True, name="3rd").start()
# spuštění producentů
threading.Thread(target=producer, daemon=True, name="1st").start()
threading.Thread(target=producer, daemon=True, name="2nd").start()
threading.Thread(target=producer, daemon=True, name="3rd").start()
threading.Thread(target=producer, daemon=True, name="3rd").start()
# čekání na zpracování všech zpráv ve frontě
q.join()
print("Done")
math# Vykreslení čar s různým sklonem
for i in range(1, 90, 5):
# převod ze stupňů na radiány
angle = math.radians(i)
radius = 150
# výpočet koncových bodů úseček
x = radius * math.sin(math.radians(i))
y = radius * math.cos(math.radians(i))
# vykreslení jedné úsečky
pygame.draw.line(display, WHITE, (WIDTH - 1, 0), (WIDTH - x, y))
sysclass Bounds:
def __init__(
self,
xmin=sys.float_info.max,
ymin=sys.float_info.max,
xmax=-sys.float_info.max,
ymax=-sys.float_info.max,
):
"""Construct new bounds using given coordinates or default values."""
self.xmin = xmin
self.ymin = ymin
self.xmax = xmax
self.ymax = ymax
osimport os
def get_event_level():
"""Get level of events to monitor (errors only, or error and warnings)."""
if os.environ.get("SENTRY_CATCH_WARNINGS", False):
return logging.WARNING
return logging.ERROR
subprocessimport subprocess
import re
def get_framebuffer_resolution(framebuffer_device):
fbset_output = subprocess.check_output(["fbset", "-s", "-fb", framebuffer_device])
for line in fbset_output.split("\n"):
line = line.strip()
if line.startswith("geometry"):
print(line)
parsed = re.match(r"geometry (\d+) (\d+)", line)
return (parsed.group(1), parsed.group(2))
print(get_framebuffer_resolution("/dev/fb0"))
#!/usr/bin/env python3
import json
data = {"x": 42, "y": [1, 2, 3, 4], "z": (1, 2, 3, 4), "w": "foobar"}
with open("test.json", "w") as fout:
json.dump(data, fout)
#!/usr/bin/env python3
import json
data = {"x": 42, "y": [1, 2, 3, 4], "z": (1, 2, 3, 4), "w": "foobar"}
with open("test.json", "w") as fout:
json.dump(data, fout, indent=4)
#!/usr/bin/env python3
import json
with open("test.json", "r") as fin:
data = json.load(fin)
print(data)
–
threading#!/usr/bin/env python3
"""Multithreading."""
import threading
import time
def worker():
threadName = threading.current_thread().name
delay = 1
n = 10
for counter in range(1, n + 1):
time.sleep(delay)
print("{}: {}/{} - {}".format(threadName, counter, n, time.ctime(time.time())))
# vytvoření a spuštění trojice vláken
threading.Thread(target=worker).start()
threading.Thread(target=worker).start()
threading.Thread(target=worker).start()
time.sleep(100)
#!/usr/bin/env python3
"""Multithreading."""
import threading
import time
def worker(threadName, delay, n):
for counter in range(1, n + 1):
time.sleep(delay)
print("{}: {}/{} - {}".format(threadName, counter, n, time.ctime(time.time())))
# vytvoření a spuštění trojice vláken
threading.Thread(target=worker, args=("Thread-1", 0.5, 10)).start()
threading.Thread(target=worker, args=("Thread-2", 1.0, 10)).start()
threading.Thread(target=worker, args=("Thread-3", 1.5, 10)).start()
time.sleep(100)
#!/usr/bin/env python3
"""Multithreading."""
import threading
import time
def worker(threadName, delay, n):
for counter in range(1, n + 1):
time.sleep(delay)
print("{}: {}/{} - {}".format(threadName, counter, n, time.ctime(time.time())))
# vytvoření trojice vláken
t1 = threading.Thread(target=worker, args=("Thread-1", 0.5, 10))
t2 = threading.Thread(target=worker, args=("Thread-2", 1.0, 10))
t3 = threading.Thread(target=worker, args=("Thread-3", 1.5, 10))
# spuštění všech vláken
t1.start()
t2.start()
t3.start()
# čekání na dokončení všech vláken
t1.join()
t2.join()
t3.join()
print("Done!")
import time
import threading
import queue
# vytvoření fronty
q = queue.Queue()
# simulace konzumenta
def consumer():
while True:
job = q.get()
print(f"Starting consuming {job}")
time.sleep(0.4)
print(f"Consumed {job}")
q.task_done()
# spuštění konzumenta
threading.Thread(target=consumer, daemon=True, name="první").start()
# vytvoření úloh v producentovi
for job in range(10):
print(f"Producing {job}")
q.put(job)
# čekání na zpracování všech zpráv ve frontě
q.join()
print("Done")
import time
import threading
import queue
# vytvoření fronty
q = queue.Queue()
# simulace konzumenta
def consumer():
name = threading.current_thread().name
while True:
job = q.get()
print(f"{name} thread: Starting consuming {job}")
time.sleep(0.4)
print(f"{name} thread: Consumed {job}")
q.task_done()
# spuštění konzumentů
threading.Thread(target=consumer, daemon=True, name="1st").start()
threading.Thread(target=consumer, daemon=True, name="2nd").start()
threading.Thread(target=consumer, daemon=True, name="3rd").start()
# vytvoření úloh v producentovi
for job in range(10):
print(f"Producing {job}")
q.put(job)
# čekání na zpracování všech zpráv ve frontě
q.join()
print("Done")
import time
import threading
import queue
# vytvoření fronty
q = queue.Queue()
# simulace producenta
def producer():
name = threading.current_thread().name
for job in range(10):
print(f"{name} thread: Starting producing {job}")
q.put(job)
time.sleep(0.3)
print(f"{name} thread: Produced {job}")
# simulace konzumenta
def consumer():
name = threading.current_thread().name
while True:
job = q.get()
print(f"{name} thread: Starting consuming {job}")
time.sleep(0.4)
print(f"{name} thread: Consumed {job}")
q.task_done()
# spuštění konzumentů
threading.Thread(target=consumer, daemon=True, name="1st").start()
threading.Thread(target=consumer, daemon=True, name="2nd").start()
threading.Thread(target=consumer, daemon=True, name="3rd").start()
# spuštění producentů
threading.Thread(target=producer, daemon=True, name="1st").start()
threading.Thread(target=producer, daemon=True, name="2nd").start()
threading.Thread(target=producer, daemon=True, name="3rd").start()
threading.Thread(target=producer, daemon=True, name="3rd").start()
# čekání na zpracování všech zpráv ve frontě
q.join()
print("Done")
import time
import threading
import queue
# vytvoření fronty
q = queue.Queue()
# simulace producenta
def producer():
name = threading.current_thread().name
for job in range(1000):
print(f"{name} thread: Starting producing {job}")
q.put(job)
time.sleep(0.3)
print(f"{name} thread: Produced {job}")
# simulace konzumenta
def consumer():
name = threading.current_thread().name
while True:
job = q.get()
print(f"{name} thread: Starting consuming {job}")
time.sleep(0.4)
print(f"{name} thread: Consumed {job}")
q.task_done()
# spuštění konzumentů
threading.Thread(target=consumer, daemon=True, name="1st").start()
threading.Thread(target=consumer, daemon=True, name="2nd").start()
threading.Thread(target=consumer, daemon=True, name="3rd").start()
# spuštění producentů
threading.Thread(target=producer, daemon=True, name="1st").start()
threading.Thread(target=producer, daemon=True, name="2nd").start()
threading.Thread(target=producer, daemon=True, name="3rd").start()
threading.Thread(target=producer, daemon=True, name="3rd").start()
# čekání na zpracování všech zpráv ve frontě
q.join()
print("Done")
import threading
import time
def worker():
threadName = threading.current_thread().name
delay = 1
n = 10
for counter in range(1, n + 1):
time.sleep(delay)
print("{}: {}/{} - {}".format(threadName, counter, n, time.ctime(time.time())))
# vytvoření a spuštění trojice vláken
threading.Thread(target=worker).start()
threading.Thread(target=worker).start()
threading.Thread(target=worker).start()
# automaticky se čeká na dokončení vláken
import threading
import time
def worker():
threadName = threading.current_thread().name
delay = 1
n = 10
for counter in range(1, n + 1):
time.sleep(delay)
print("{}: {}/{} - {}".format(threadName, counter, n, time.ctime(time.time())))
# vytvoření a spuštění trojice vláken v režimu daemon
threading.Thread(target=worker, daemon=True).start()
threading.Thread(target=worker, daemon=True).start()
threading.Thread(target=worker, daemon=True).start()
# na dokončení vláken se nečeká!
import threading
import time
def worker():
threadName = threading.current_thread().name
delay = 1
n = 10
for counter in range(1, n + 1):
time.sleep(delay)
print("{}: {}/{} - {}".format(threadName, counter, n, time.ctime(time.time())))
# vytvoření a spuštění trojice vláken v režimu daemon
t1 = threading.Thread(target=worker, daemon=True)
t2 = threading.Thread(target=worker, daemon=True)
t3 = threading.Thread(target=worker, daemon=True)
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()
import threading
import time
def worker(threadName, delay, n):
for counter in range(1, n + 1):
time.sleep(delay)
print("{}: {}/{} - {}".format(threadName, counter, n, time.ctime(time.time())))
# vytvoření trojice vláken
t1 = threading.Thread(target=worker, args=("Thread-1", 0.5, 10))
t2 = threading.Thread(target=worker, args=("Thread-2", 1.0, 10))
t3 = threading.Thread(target=worker, args=("Thread-3", 1.5, 10))
# spuštění všech vláken
t1.start()
t2.start()
t3.start()
# čekání na dokončení všech vláken
t3.join(timeout=5)
if t3.is_alive():
print("wait timeout")
else:
print("t3 has finished")
t2.join()
print("t2 has finished")
t1.join()
print("t1 has finished")
print("Done!")
concurrent.futuresfrom concurrent.futures.thread import ThreadPoolExecutor
import time
def worker(threadName, delay, n):
for counter in range(1, n + 1):
time.sleep(delay)
print("{}: {}/{} - {}".format(threadName, counter, n, time.ctime(time.time())))
with ThreadPoolExecutor(max_workers=3) as executor:
executor.submit(worker, "Thread-1", 0.5, 10)
executor.submit(worker, "Thread-2", 1.0, 10)
executor.submit(worker, "Thread-3", 1.5, 10)
print("Done!")
from concurrent.futures.thread import ThreadPoolExecutor
import time
def worker(threadName, delay, n):
for counter in range(1, n + 1):
time.sleep(delay)
print("{}: {}/{} - {}".format(threadName, counter, n, time.ctime(time.time())))
print("{}: DONE!".format(threadName))
workers = 10
with ThreadPoolExecutor(max_workers=workers) as executor:
for w in range(workers):
executor.submit(worker, "Thread-{}".format(w + 1), 0.5 + w / 10.0, 10)
print("Done!")
multiprocessingfrom multiprocessing import Process
def worker(name):
print("hello", name)
def main():
p = Process(target=worker, args=("foo",))
p.start()
p.join()
if __name__ == "__main__":
print("Running main")
main()
from multiprocessing import Process
import time
def worker(name):
print("hello", name)
time.sleep(5)
print("done", name)
def main():
ps = []
for name in ("foo", "bar", "baz", "other"):
p = Process(target=worker, args=(name,))
p.start()
ps.append(p)
for p in ps:
p.join()
if __name__ == "__main__":
print("Running main")
main()
from multiprocessing import Process
import time
def worker(name):
print("hello", name)
time.sleep(5)
print("done", name)
def main():
ps = [
Process(target=worker, args=(name,)) for name in ("foo", "bar", "baz", "other")
]
for p in ps:
p.start()
for p in ps:
p.join()
if __name__ == "__main__":
print("Running main")
main()
from multiprocessing import Process, Queue
import time
def worker(name, q):
while True:
cmd = q.get()
print(name, cmd)
if cmd == "quit":
print("Quitting")
return
time.sleep(1)
def main():
q = Queue()
ps = [Process(target=worker, args=(name, q)) for name in ("foo", "bar", "baz")]
for p in ps:
p.start()
for i in range(10):
q.put("command {}".format(i))
for i in range(3):
q.put("quit")
for p in ps:
p.join()
if __name__ == "__main__":
print("Running main")
main()
from multiprocessing import Process, Pipe
import time
def worker(name, conn):
while True:
cmd = conn.recv()
print("{} received {}".format(name, cmd))
if cmd == "quit":
return
else:
conn.send("{} accepted {}".format(name, cmd))
time.sleep(1)
def main():
parent_conn, child_conn = Pipe()
p = Process(target=worker, args=("Worker", child_conn))
p.start()
for i in range(10):
parent_conn.send("command {}".format(i))
print(parent_conn.recv())
parent_conn.send("quit")
p.join()
if __name__ == "__main__":
main()
from machine import Pin
pin = Pin(0, Pin.IN)
print(pin.value())
from machine import Pin
pin = Pin(14, Pin.OUT)
pin.value(1)
PyObject *cdefdef calc(width, height, maxiter, palette):
...
...
...
cdef calc(int width, int height, int maxiter, palette):
...
...
...
–
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Serializce hodnot do souboru."""
import pickle
data = {"x": "Hello", "y": "world", "z": [1, 2, 3, 4], "w": (1, 2, 3, 4)}
with open("test", "wb") as fout:
pickle.dump(data, fout)
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Serializce hodnot do souboru se specifikací protokolu."""
import pickle
data = {"x": "Hello", "y": "world", "z": [1, 2, 3, 4], "w": (1, 2, 3, 4)}
with open("test", "wb") as fout:
pickle.dump(data, fout, pickle.HIGHEST_PROTOCOL)
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Deserializce hodnot ze souboru."""
import pickle
with open("test", "rb") as fin:
data = pickle.load(fin)
print(data)
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Serializace objektů do souboru."""
import pickle
class Employee:
"""Třída reprezentující zaměstnance."""
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
self._first_name = first_name
self._surname = surname
self._salary = salary
self._poznamka = 124
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "name: {name} {surname} Salary: {salary}".format(
name=self._first_name, surname=self._surname, salary=self._salary
)
def __eq__(self, other):
if other is None:
return False
return (
self._first_name == other._first_name
and self._surname == other._surname
and self._salary == other._salary
)
# vytvoření tří instancí třídy
employee1 = Employee("Eda", "Wasserfall", 10000)
employee2 = Employee("Eda", "Wasserfall", 10000)
employee3 = Employee("Přemysl", "Hájek", 25001)
with open("test", "wb") as fout:
data = [employee1, employee2, employee3]
pickle.dump(data, fout)
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Serializace objektů do souboru."""
import pickle
class Employee:
"""Třída reprezentující zaměstnance."""
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
self._first_name = first_name
self._surname = surname
self._salary = salary
self._poznamka = 124
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "name: {name} {surname} Salary: {salary}".format(
name=self._first_name, surname=self._surname, salary=self._salary
)
def __eq__(self, other):
if other is None:
return False
return (
self._first_name == other._first_name
and self._surname == other._surname
and self._salary == other._salary
)
with open("test", "rb") as fin:
employees = pickle.load(fin)
for employee in employees:
print(employee)
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Zápis prvků do databáze."""
import shelve
with shelve.open("test") as db:
db["x"] = "Hello"
db["y"] = "world"
db["z"] = [1, 2, 3, 4]
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Čtení prvků z databáze."""
import shelve
with shelve.open("test") as db:
print(db["x"])
print(db["y"])
print(db["z"])
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Zápis objektů do databáze."""
import shelve
class Employee:
"""Třída reprezentující zaměstnance."""
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
self._first_name = first_name
self._surname = surname
self._salary = salary
self._poznamka = 124
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "name: {name} {surname} Salary: {salary}".format(
name=self._first_name, surname=self._surname, salary=self._salary
)
def __eq__(self, other):
if other is None:
return False
return (
self._first_name == other._first_name
and self._surname == other._surname
and self._salary == other._salary
)
# vytvoření tří instancí třídy
employee1 = Employee("Eda", "Wasserfall", 10000)
employee2 = Employee("Eda", "Wasserfall", 10000)
employee3 = Employee("Přemysl", "Hájek", 25001)
with shelve.open("test") as db:
db["employee1"] = employee1
db["employee2"] = employee2
db["employee3"] = employee3
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
"""Přečtení objektů z databáze."""
import shelve
class Employee:
"""Třída reprezentující zaměstnance."""
def __init__(self, first_name, surname, salary):
"""Konstruktor objektu."""
self._first_name = first_name
self._surname = surname
self._salary = salary
self._poznamka = 124
def __str__(self):
"""Speciální metoda pro převod objektu na řetězec."""
return "name: {name} {surname} Salary: {salary}".format(
name=self._first_name, surname=self._surname, salary=self._salary
)
def __eq__(self, other):
if other is None:
return False
return (
self._first_name == other._first_name
and self._surname == other._surname
and self._salary == other._salary
)
with shelve.open("test") as db:
print(db["employee1"])
print(db["employee2"])
print(db["employee3"])
#!/usr/bin/env python3
from kafka import KafkaProducer
from time import sleep
from json import dumps
server = "localhost:9092"
topic = "upload"
print("Connecting to Kafka")
producer = KafkaProducer(
bootstrap_servers=[server], value_serializer=lambda x: dumps(x).encode("utf-8")
)
print("Connected to Kafka")
for i in range(1000):
data = {"counter": i}
producer.send(topic, value=data)
sleep(5)
#!/usr/bin/env python3
import sys
from kafka import KafkaConsumer
server = "localhost:9092"
topic = "upload"
group_id = "group1"
print("Connecting to Kafka")
consumer = KafkaConsumer(
topic, group_id=group_id, bootstrap_servers=[server], auto_offset_reset="earliest"
)
print("Connected to Kafka")
try:
for message in consumer:
print(
"%s:%d:%d: key=%s value=%s"
% (
message.topic,
message.partition,
message.offset,
message.key,
message.value,
)
)
except KeyboardInterrupt:
sys.exit()
#!/usr/bin/env python3
import sys
from kafka import KafkaConsumer, TopicPartition
server = "localhost:9092"
topic = "upload"
group_id = "group1"
print("Connecting to Kafka")
consumer = KafkaConsumer(group_id=group_id, bootstrap_servers=[server])
print("Connected to Kafka")
tp = TopicPartition(topic=topic, partition=0)
consumer.assign([tp])
consumer.seek(tp, 0)
try:
for message in consumer:
print(
"%s:%d:%d: key=%s value=%s"
% (
message.topic,
message.partition,
message.offset,
message.key,
message.value,
)
)
except KeyboardInterrupt:
sys.exit()
–
pytest1 unittest
2 doctest
3 pytest
4 nose
5 testify
6 Trial
7 Twisted
8 subunit
9 testresources
10 reahl.tofu
11 unit testing
12 testtools
13 Sancho
14 zope.testing
15 pry
16 pythoscope
17 testlib
18 pytest
19 dutest
Různé podoby testovací pyramidy
–
PyjamasDesktop (pyjs Desktop)
#!/usr/bin/env python
from tkinter import *
from tkinter import ttk
root = Tk()
label = ttk.Label(root, text="Hello world!")
label.pack()
root.mainloop()
#!/usr/bin/env python
from appJar import gui
app = gui()
app.addLabel("title", "Hello world!")
app.go()
import pygtk
pygtk.require("2.0")
import gtk
def delete_event(widget, event, data=None):
print "delete event occurred"
return False
def destroy(widget, data=None):
print "destroy signal occurred"
gtk.main_quit()
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.connect("delete_event", delete_event)
window.connect("destroy", destroy)
label = gtk.Label("Hello world!")
window.add(label)
label.show()
window.show()
gtk.main()
import pygtk
pygtk.require("2.0")
import gtk
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
label = gtk.Label("Hello world!")
window.add(label)
label.show()
window.show()
gtk.main()
import sys
# zajisteni importu noveho rozhrani
import sip
sip.setapi("QDate", 2)
sip.setapi("QDateTime", 2)
sip.setapi("QString", 2)
sip.setapi("QTextStream", 2)
sip.setapi("QTime", 2)
sip.setapi("QUrl", 2)
sip.setapi("QVariant", 2)
from PyQt4.Qt import *
qt_application = QApplication(sys.argv)
label = QLabel("Hello world!")
label.show()
qt_application.exec_()
import sys
from PySide.QtCore import *
from PySide.QtGui import *
qt_application = QApplication(sys.argv)
label = QLabel("Hello world!")
label.show()
qt_application.exec_()
import sys
from PySide.QtCore import *
from PySide.QtGui import *
qt_application = QApplication(sys.argv)
class HelloWorldLabel(QLabel):
def __init__(self):
QLabel.__init__(self, "Hello world!")
self.setMinimumSize(QSize(600, 400))
self.setAlignment(Qt.AlignCenter)
self.setWindowTitle("Hello world!")
def run(self):
self.show()
qt_application.exec_()
HelloWorldLabel().run()
# vim: set fileencoding=utf-8
from wx import App, Frame, ID_ANY
# vytvoření instance objektu představujícího běžící aplikaci
app = App()
# vytvoření hlavního okna se specifikací jeho vlastností a titulku
frame = Frame(None, ID_ANY, "wxPython!")
# zobrazení hlavního okna aplikace
frame.Show(True)
# vstup do smyčky pro čtení a zpracování událostí (event loop)
app.MainLoop()
from kivy.app import App
from kivy.uix.label import Label
class TestApp(App):
def build(self):
return Label(text="Hello World")
TestApp().run()
Jméno widgetu Význam a funkce
---------------------------------
label widget, který zobrazuje v okně či dialogu měnitelný text
button graficky zobrazené tlačítko, které implicitně reaguje na levé tlačítko myši
checkbutton dvoustavový přepínač, který implicitně reaguje na levé tlačítko myši
radiobutton widget, jichž může být sdruženo větší množství, vždy pouze jeden je vybraný
scale dnes nazýván pojmem slider atd., jedná se o widget s posuvnou částí a přidruženým textem, kde se zobrazuje hodnota v závislosti na poloze posuvné části
entry widget, do kterého je možné zapisovat text, k tomu má přidruženo mnoho klávesových zkratek (jde o kombinaci staršího a novějšího standardu)
spinbox widget určený pro zadávání číselných hodnot kombinací klávesnice a myši (i s kontrolou mezí)
menu vertikální menu, které se skládá z více položek
menubutton používá se spolu s menu pro vytváření jednotlivých položek
listbox widget, jež nabízí na výběr libovolné množství řádků s textem
scrollbar podobné widgetu scale s tím rozdílem, že zobrazuje posuvné šipky a naopak nezobrazuje přidruženou číselnou hodnotu
frame jeden z několika nabízených kontejnerů; tento má tvar obdélníka (může být také neviditelný nebo může mít 3D rámeček)
toplevel další z kontejnerů, tento se chová jako samostatné okno či dialog
bitmap bitmapa, tj. rastrový obrázek
photo/photoimage rastrový obrázek, jež může být načten z externího souboru v mnoha různých formátech
canvas widget, na který lze programově vkládat další grafické komponenty (úsečky, oblouky, kružnice, polyčáry, text atd.)
Jméno vlastnosti Popis vlastnosti
------------------------------------
background barva pozadí widgetu v případě, že widget není aktivní (vybraný)
foreground barva popředí widgetu (například zobrazeného textu) v případě, že widget není aktivní (vybraný)
borderwidth šířka okraje widgetu, která je zadaná v pixelech
activebackground barva pozadí widgetu v případě, že je widget vybrán (typicky kurzorem myši)
activeforeground barva popředí widgetu v případě, že je widget vybrán
disabledforeground barva popředí widgetu v případě, že je ovládání widgetu zakázáno
relief způsob prostorového zobrazení widgetu
compound způsob umístění bitmapy či obrázku na widgetu
bitmap bitmapa, která má být ve widgetu zobrazena
image obrázek, který má být ve widgetu zobrazen (více o bitmapách a obrázcích bude uvedeno v dalších dílech)
font jméno fontu, který je použit pro text uvnitř widgetu (font lze specifikovat platformově nezávislým způsobem)
text text, který má být ve widgetu (tlačítko, položka menu atd.) zobrazen
cursor jméno kurzoru myši, který bude použit v případě, že se kurzor nachází nad widgetem
textvariable jméno proměnné, která je nastavována podle uživatelových manipulací s widgetem (StringVar v Tkinteru)
justify zarovnání textu ve widgetu v případě, že se zobrazuje více řádků
anchor způsob umístění textu či obrázku ve widgetu
showinfo()showwarning()showerror()askokcancel()askretrycancel()askyesno()askquestion()messagebox.showinfo("Title", "Text"))
messagebox.showwarning("Title", "Text"))
messagebox.showerror("Title", "Text"))
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
root = tkinter.Tk()
label = ttk.Label(root, text="Hello world!")
label.pack()
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
def exit():
sys.exit(0)
root = tkinter.Tk()
label = ttk.Label(root, text="Hello world!")
button = ttk.Button(root, text="Close window", command=exit)
label.pack()
button.pack()
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
label = ttk.Label(root, text="Hello world!")
button = ttk.Button(root, text="Close window", command=lambda: sys.exit(0))
label.pack()
button.pack()
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
button1 = ttk.Button(root, text="First button")
button2 = ttk.Button(root, text="Second button")
button3 = ttk.Button(root, text="Third button")
button4 = ttk.Button(root, text="Fourth button")
button1.grid(column=1, row=1)
button2.grid(column=2, row=1)
button3.grid(column=1, row=2)
button4.grid(column=2, row=2)
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
button1 = ttk.Button(root, text="First button", command=lambda: sys.exit(0))
button2 = ttk.Button(root, text="Second button", command=lambda: sys.exit(0))
button3 = ttk.Button(root, text="Third button", command=lambda: sys.exit(0))
button4 = ttk.Button(root, text="Fourth button", command=lambda: sys.exit(0))
button1.grid(column=1, row=1)
button2.grid(column=2, row=1)
button3.grid(column=1, row=2)
button4.grid(column=2, row=2)
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
from tkinter import *
from tkinter import ttk
import sys
root = Tk()
button1 = ttk.Button(root, text="First button")
button2 = ttk.Button(root, text="Second button with long text")
button3 = ttk.Button(root, text="Third button")
button4 = ttk.Button(root, text="Fourth button")
button1.pack()
button2.pack()
button3.pack()
button4.pack()
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
from tkinter import *
from tkinter import ttk
import sys
root = Tk()
button1 = ttk.Button(root, text="First button")
button2 = ttk.Button(root, text="Second button")
button3 = ttk.Button(root, text="Third button")
button4 = ttk.Button(root, text="Fourth button")
button1.grid(column=2, row=4)
button2.grid(column=3, row=1)
button3.grid(column=1, row=3)
button4.grid(column=4, row=2)
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
from tkinter import *
from tkinter import ttk
import sys
root = Tk()
button1 = ttk.Button(root, text="First button", command=lambda: sys.exit(0))
button2 = ttk.Button(root, text="Second button", command=lambda: sys.exit(0))
button3 = ttk.Button(root, text="Third button", command=lambda: sys.exit(0))
button4 = ttk.Button(root, text="Fourth button", command=lambda: sys.exit(0))
button1.grid(column=2, row=4)
button2.grid(column=3, row=1)
button3.grid(column=1, row=3)
button4.grid(column=4, row=2)
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
from tkinter import *
from tkinter import ttk
import sys
root = Tk()
button1 = ttk.Button(root, text="First button", command=lambda: sys.exit(0))
button2 = ttk.Button(root, text="Second button", command=lambda: sys.exit(0))
button3 = ttk.Button(root, text="Third button", command=lambda: sys.exit(0))
button4 = ttk.Button(root, text="Fourth button", command=lambda: sys.exit(0))
button1.grid(column=1, row=1)
button2.grid(column=2, row=2)
button3.grid(column=1, row=3, columnspan=2)
button4.grid(column=4, row=1, rowspan=3)
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
from tkinter import *
from tkinter import ttk
import sys
root = Tk()
button1 = ttk.Button(root, text="1st btn", command=lambda: sys.exit(0))
button2 = ttk.Button(root, text="Second button", command=lambda: sys.exit(0))
button3 = ttk.Button(root, text="Third button", command=lambda: sys.exit(0))
button4 = ttk.Button(
root, text="This is fourth button, the last one", command=lambda: sys.exit(0)
)
button1.grid(column=1, row=1)
button2.grid(column=2, row=1)
button3.grid(column=1, row=2)
button4.grid(column=2, row=2)
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
from tkinter import *
from tkinter import ttk
import sys
root = Tk()
button1 = ttk.Button(root, text="1st btn", command=lambda: sys.exit(0))
button2 = ttk.Button(root, text="Second button", command=lambda: sys.exit(0))
button3 = ttk.Button(root, text="Third button", command=lambda: sys.exit(0))
button4 = ttk.Button(
root, text="This is fourth button, the last one", command=lambda: sys.exit(0)
)
button1.grid(column=1, row=1, sticky="w")
button2.grid(column=2, row=1, sticky="w")
button3.grid(column=1, row=2, sticky="w")
button4.grid(column=2, row=2, sticky="w")
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
from tkinter import *
from tkinter import ttk
import sys
root = Tk()
button1 = ttk.Button(root, text="1st btn", command=lambda: sys.exit(0))
button2 = ttk.Button(root, text="Second button", command=lambda: sys.exit(0))
button3 = ttk.Button(root, text="Third button", command=lambda: sys.exit(0))
button4 = ttk.Button(
root, text="This is fourth button, the last one", command=lambda: sys.exit(0)
)
button1.grid(column=1, row=1, sticky="e")
button2.grid(column=2, row=1, sticky="e")
button3.grid(column=1, row=2, sticky="e")
button4.grid(column=2, row=2, sticky="e")
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
from tkinter import *
from tkinter import ttk
import sys
root = Tk()
button1 = ttk.Button(root, text="1st btn", command=lambda: sys.exit(0))
button2 = ttk.Button(root, text="Second button", command=lambda: sys.exit(0))
button3 = ttk.Button(root, text="Third button", command=lambda: sys.exit(0))
button4 = ttk.Button(
root, text="This is fourth button, the last one", command=lambda: sys.exit(0)
)
button1.grid(column=1, row=1, sticky="we")
button2.grid(column=2, row=1, sticky="we")
button3.grid(column=1, row=2, sticky="we")
button4.grid(column=2, row=2, sticky="we")
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
from tkinter import *
from tkinter import ttk
import sys
root = Tk()
button1 = ttk.Button(root, text="1st btn", command=lambda: sys.exit(0))
button2 = ttk.Button(root, text="Second button", command=lambda: sys.exit(0))
button3 = ttk.Button(root, text="Third button", command=lambda: sys.exit(0))
button4 = ttk.Button(
root, text="This is fourth button, the last one", command=lambda: sys.exit(0)
)
button1.grid(column=1, row=1, sticky="we")
button2.grid(column=2, row=2, sticky="we")
button3.grid(column=1, row=3, sticky="we")
button4.grid(column=3, row=1, rowspan=4, sticky="nswe")
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
import sys
root = tkinter.Tk()
button1 = tkinter.Button(
root, background="yellow", text="1st btn", command=lambda: sys.exit(0)
)
button2 = tkinter.Button(
root, background="#ff8080", text="Second button", command=lambda: sys.exit(0)
)
button3 = tkinter.Button(root, text="Third button", command=lambda: sys.exit(0))
button4 = tkinter.Button(
root, text="This is fourth button, the last one", command=lambda: sys.exit(0)
)
button3.configure(background="#8080ff")
button4["background"] = "#80ff80"
button1.grid(column=1, row=1, sticky="we")
button2.grid(column=2, row=1, sticky="we")
button3.grid(column=1, row=2, sticky="we")
button4.grid(column=2, row=2, sticky="we")
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
def exit():
sys.exit(0)
root = tkinter.Tk()
style = ttk.Style()
style.configure("Yellow.TButton", background="yellow")
style.configure("Red.TButton", background="#ff8080")
style.configure("Blue.TButton", background="#8080ff")
style.configure("Green.TButton", background="#80ff80")
button1 = ttk.Button(root, text="1st btn", style="Yellow.TButton", command=exit)
button2 = ttk.Button(root, text="Second button", style="Red.TButton", command=exit)
button3 = ttk.Button(root, text="Third button", command=exit)
button4 = ttk.Button(root, text="This is fourth button, the last one", command=exit)
button3.configure(style="Green.TButton")
button4["style"] = "Blue.TButton"
button1.grid(column=1, row=1, sticky="we")
button2.grid(column=2, row=1, sticky="we")
button3.grid(column=1, row=2, sticky="we")
button4.grid(column=2, row=2, sticky="we")
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
style = ttk.Style()
print(style.theme_names())
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
def exit():
sys.exit(0)
root = tkinter.Tk()
style = ttk.Style()
style.configure("Red.TButton", background="#ff8080")
button1 = ttk.Button(root, text="clam", command=lambda: style.theme_use("clam"))
button2 = ttk.Button(root, text="alt", command=lambda: style.theme_use("alt"))
button3 = ttk.Button(root, text="default", command=lambda: style.theme_use("default"))
button4 = ttk.Button(root, text="classic", command=lambda: style.theme_use("classic"))
quitButton = ttk.Button(root, text="Exit", style="Red.TButton", command=exit)
button1.grid(column=1, row=1, sticky="we")
button2.grid(column=2, row=1, sticky="we")
button3.grid(column=1, row=2, sticky="we")
button4.grid(column=2, row=2, sticky="we")
quitButton.grid(column=2, row=5, sticky="we")
label = tkinter.Label(root, text="Hello world")
entry = tkinter.Entry(root)
checkbutton = tkinter.Checkbutton(text="Do you like Tkinter?")
checkbutton.grid(column=1, row=3, columnspan=2, sticky="w")
label.grid(column=1, row=4)
entry.grid(column=2, row=4)
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
def exit():
sys.exit(0)
root = tkinter.Tk()
style = ttk.Style()
for style_name in ("clam", "alt", "default", "classic"):
style.theme_use(style_name)
style.configure("Red.TButton", background="#ff8080")
button1 = ttk.Button(root, text="clam", command=lambda: style.theme_use("clam"))
button2 = ttk.Button(root, text="alt", command=lambda: style.theme_use("alt"))
button3 = ttk.Button(root, text="default", command=lambda: style.theme_use("default"))
button4 = ttk.Button(root, text="classic", command=lambda: style.theme_use("classic"))
quitButton = ttk.Button(root, text="Exit", style="Red.TButton", command=exit)
button1.grid(column=1, row=1, sticky="we")
button2.grid(column=2, row=1, sticky="we")
button3.grid(column=1, row=2, sticky="we")
button4.grid(column=2, row=2, sticky="we")
quitButton.grid(column=2, row=5, sticky="we")
label = tkinter.Label(root, text="Hello world")
entry = tkinter.Entry(root)
checkbutton = tkinter.Checkbutton(text="Do you like Tkinter?")
checkbutton.grid(column=1, row=3, columnspan=2, sticky="w")
label.grid(column=1, row=4)
entry.grid(column=2, row=4)
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
def exit():
sys.exit(0)
root = tkinter.Tk()
style = ttk.Style()
style.configure("Red.TButton", background="#ff8080")
button1 = tkinter.Button(root, text="sunken", relief="sunken")
button2 = tkinter.Button(root, text="solid", relief="solid")
button3 = tkinter.Button(root, text="flat", relief="flat")
button4 = tkinter.Button(root, text="groove", relief="groove")
button5 = tkinter.Button(root, text="raised", relief="raised")
button6 = tkinter.Button(root, text="ridge", relief="ridge")
quitButton = ttk.Button(root, text="Exit", style="Red.TButton", command=exit)
button1.grid(column=1, row=1, sticky="we")
button2.grid(column=1, row=2, sticky="we")
button3.grid(column=1, row=3, sticky="we")
button4.grid(column=1, row=4, sticky="we")
button5.grid(column=1, row=5, sticky="we")
button6.grid(column=1, row=6, sticky="we")
quitButton.grid(column=2, row=6, sticky="we")
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
def exit():
sys.exit(0)
root = tkinter.Tk()
style = ttk.Style()
style.configure("Red.TButton", background="#ff8080")
buttonStyles = ("sunken", "solid", "flat", "groove", "raised", "ridge")
buttons = (
tkinter.Button(root, text=buttonStyle, relief=buttonStyle)
for buttonStyle in buttonStyles
)
quitButton = ttk.Button(root, text="Exit", style="Red.TButton", command=exit)
for i, button in enumerate(buttons):
button.grid(column=1, row=i, sticky="we")
quitButton.grid(column=2, row=6, sticky="we")
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
def exit():
sys.exit(0)
root = tkinter.Tk()
style = ttk.Style()
style.configure("Red.TButton", background="#ff8080")
buttonStyles = ("sunken", "solid", "flat", "groove", "raised", "ridge")
buttons = (
tkinter.Button(root, text=buttonStyle, relief=buttonStyle)
for buttonStyle in buttonStyles
)
quitButton = ttk.Button(root, text="Exit", style="Red.TButton", command=exit)
for i, button in enumerate(buttons):
button.grid(column=1, row=i, sticky="we", padx=6, pady=6)
quitButton.grid(column=2, row=6, sticky="we", padx=6, pady=6)
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
def exit():
sys.exit(0)
root = tkinter.Tk()
style = ttk.Style()
style.configure("Red.TButton", background="#ff8080")
buttonStyles = ("sunken", "solid", "flat", "groove", "raised", "ridge")
buttons = (
Button(root, text=buttonStyle, relief=buttonStyle, borderwidth=2)
for buttonStyle in buttonStyles
)
quitButton = ttk.Button(root, text="Exit", style="Red.TButton", command=exit)
for i, button in enumerate(buttons):
button.grid(column=1, row=i, sticky="we", padx=6, pady=6)
quitButton.grid(column=2, row=6, sticky="we", padx=6, pady=6)
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
def exit():
sys.exit(0)
root = tkinter.Tk()
style = ttk.Style()
style.configure("Red.TButton", background="#ff8080")
button1 = ttk.Button(root, text="1s button", command=exit)
button2 = ttk.Button(root, text="2nd button with long text", command=exit)
button3 = ttk.Button(root, text="3rd button", command=exit)
button4 = ttk.Button(root, text="4th button", command=exit)
quitButton = ttk.Button(root, text="Exit", style="Red.TButton", command=exit)
button1.pack()
button2.pack()
button3.pack()
button4.pack()
label = tkinter.Label(root, text="Hello world")
entry = tkinter.Entry(root)
checkbutton = tkinter.Checkbutton(text="Do you like Tkinter?")
checkbutton.pack()
label.pack()
entry.pack()
quitButton.pack()
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
style = ttk.Style()
style.configure("Red.TButton", background="#ff8080")
checkbutton = ttk.Checkbutton(
root, text="Delete Internet?", command=lambda: print("changed")
)
quitButton = ttk.Button(root, text="Exit", style="Red.TButton", command=exit)
checkbutton.grid(column=1, row=1, sticky="we", padx=6, pady=6)
quitButton.grid(column=1, row=2, sticky="we", padx=6, pady=6)
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
style = ttk.Style()
style.theme_use("alt")
style.configure("Red.TButton", background="#ff8080")
checkbutton = ttk.Checkbutton(
root, text="Delete Internet?", command=lambda: print("changed")
)
quitButton = ttk.Button(root, text="Exit", style="Red.TButton", command=exit)
checkbutton.grid(column=1, row=1, sticky="we", padx=6, pady=6)
quitButton.grid(column=1, row=2, sticky="we", padx=6, pady=6)
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
style = ttk.Style()
style.theme_use("alt")
style.configure("Red.TButton", background="#ff8080")
delete_internet = tkinter.IntVar()
checkbutton = ttk.Checkbutton(
root,
text="Delete Internet?",
variable=delete_internet,
command=lambda: print(delete_internet.get()),
)
quitButton = ttk.Button(root, text="Exit", style="Red.TButton", command=exit)
checkbutton.grid(column=1, row=1, sticky="we", padx=6, pady=6)
quitButton.grid(column=1, row=2, sticky="we", padx=6, pady=6)
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
style = ttk.Style()
style.theme_use("alt")
style.configure("Red.TButton", background="#ff8080")
delete_internet = tkinter.StringVar()
checkbutton = ttk.Checkbutton(
root,
text="Delete Internet?",
variable=delete_internet,
onvalue="yes",
offvalue="no",
command=lambda: print(delete_internet.get()),
)
quitButton = ttk.Button(root, text="Exit", style="Red.TButton", command=exit)
checkbutton.grid(column=1, row=1, sticky="we", padx=6, pady=6)
quitButton.grid(column=1, row=2, sticky="we", padx=6, pady=6)
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
style = ttk.Style()
style.theme_use("alt")
style.configure("Red.TButton", background="#ff8080")
entry = ttk.Entry(root)
entry.insert(0, "xyzzy")
quitButton = ttk.Button(root, text="Exit", style="Red.TButton", command=exit)
entry.grid(column=1, row=1, sticky="we", padx=6, pady=6)
quitButton.grid(column=1, row=2, sticky="we", padx=6, pady=6)
root.mainloop()
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
style = ttk.Style()
style.theme_use("alt")
style.configure("Red.TButton", background="#ff8080")
value = tkinter.StringVar()
entry = ttk.Entry(root, textvariable=value)
entry.insert(0, "xyzzy")
showButton = ttk.Button(root, text="Show var", command=lambda: print(value.get()))
quitButton = ttk.Button(root, text="Exit", style="Red.TButton", command=exit)
entry.grid(column=1, row=1, sticky="we", padx=6, pady=6)
showButton.grid(column=1, row=2, sticky="we", padx=6, pady=6)
quitButton.grid(column=1, row=3, sticky="we", padx=6, pady=6)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
import sys
root = tkinter.Tk()
radio_var = tkinter.StringVar()
radio1 = tkinter.Radiobutton(
root, variable=radio_var, value="Assembler", text="Assembler"
)
radio2 = tkinter.Radiobutton(root, variable=radio_var, value="Basic", text="Basic")
radio3 = tkinter.Radiobutton(
root, variable=radio_var, value="Brainfuck", text="Brainfuck"
)
radio4 = tkinter.Radiobutton(root, variable=radio_var, value="C", text="C")
radio5 = tkinter.Radiobutton(root, variable=radio_var, value="Python", text="Python")
showButton = tkinter.Button(
root, text="Show var", command=lambda: print(radio_var.get())
)
quitButton = tkinter.Button(root, text="Exit", background="#ff8080", command=exit)
radio1.grid(column=1, row=1)
radio2.grid(column=1, row=2)
radio3.grid(column=1, row=3)
radio4.grid(column=1, row=4)
radio5.grid(column=1, row=5)
showButton.grid(column=2, row=6, sticky="we", padx=6, pady=6)
quitButton.grid(column=2, row=7, sticky="we", padx=6, pady=6)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
import sys
root = tkinter.Tk()
radio_var = tkinter.StringVar()
radio1 = tkinter.Radiobutton(
root, variable=radio_var, value="Assembler", text="Assembler"
)
radio2 = tkinter.Radiobutton(root, variable=radio_var, value="Basic", text="Basic")
radio3 = tkinter.Radiobutton(
root, variable=radio_var, value="Brainfuck", text="Brainfuck"
)
radio4 = tkinter.Radiobutton(root, variable=radio_var, value="C", text="C")
radio5 = tkinter.Radiobutton(root, variable=radio_var, value="Python", text="Python")
showButton = tkinter.Button(
root, text="Show var", command=lambda: print(radio_var.get())
)
quitButton = tkinter.Button(root, text="Exit", background="#ff8080", command=exit)
radio1.grid(column=1, row=1, sticky="w")
radio2.grid(column=1, row=2, sticky="w")
radio3.grid(column=1, row=3, sticky="w")
radio4.grid(column=1, row=4, sticky="w")
radio5.grid(column=1, row=5, sticky="w")
showButton.grid(column=2, row=6, sticky="we", padx=6, pady=6)
quitButton.grid(column=2, row=7, sticky="we", padx=6, pady=6)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
import sys
root = tkinter.Tk()
radio_var = tkinter.StringVar()
radio_var.set("C")
radio1 = tkinter.Radiobutton(
root, variable=radio_var, value="Assembler", text="Assembler"
)
radio2 = tkinter.Radiobutton(root, variable=radio_var, value="Basic", text="Basic")
radio3 = tkinter.Radiobutton(
root, variable=radio_var, value="Brainfuck", text="Brainfuck"
)
radio4 = tkinter.Radiobutton(root, variable=radio_var, value="C", text="C")
radio5 = tkinter.Radiobutton(root, variable=radio_var, value="Python", text="Python")
showButton = tkinter.Button(
root, text="Show var", command=lambda: print(radio_var.get())
)
quitButton = tkinter.Button(root, text="Exit", background="#ff8080", command=exit)
radio1.grid(column=1, row=1, sticky="w")
radio2.grid(column=1, row=2, sticky="w")
radio3.grid(column=1, row=3, sticky="w")
radio4.grid(column=1, row=4, sticky="w")
radio5.grid(column=1, row=5, sticky="w")
showButton.grid(column=2, row=6, sticky="we", padx=6, pady=6)
quitButton.grid(column=2, row=7, sticky="we", padx=6, pady=6)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
style = ttk.Style()
style.theme_use("alt")
style.configure("Red.TButton", background="#ff8080")
radio_var = tkinter.StringVar()
radio_var.set("Python")
radio1 = ttk.Radiobutton(root, variable=radio_var, value="Assembler", text="Assembler")
radio2 = ttk.Radiobutton(root, variable=radio_var, value="Basic", text="Basic")
radio3 = ttk.Radiobutton(root, variable=radio_var, value="Brainfuck", text="Brainfuck")
radio4 = ttk.Radiobutton(root, variable=radio_var, value="C", text="C")
radio5 = ttk.Radiobutton(root, variable=radio_var, value="Python", text="Python")
showButton = ttk.Button(root, text="Show var", command=lambda: print(radio_var.get()))
quitButton = ttk.Button(root, text="Exit", style="Red.TButton", command=exit)
radio1.grid(column=1, row=1, sticky="w")
radio2.grid(column=1, row=2, sticky="w")
radio3.grid(column=1, row=3, sticky="w")
radio4.grid(column=1, row=4, sticky="w")
radio5.grid(column=1, row=5, sticky="w")
showButton.grid(column=2, row=6, sticky="we", padx=6, pady=6)
quitButton.grid(column=2, row=7, sticky="we", padx=6, pady=6)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
style = ttk.Style()
style.theme_use("alt")
style.configure("Red.TButton", background="#ff8080")
radio_var = tkinter.StringVar()
radio_var.set("Python")
langs = ("Assembler", "Basic", "Brainfuck", "C", "Python")
radio_buttons = (
ttk.Radiobutton(root, text=lang, value=lang, variable=radio_var) for lang in langs
)
showButton = ttk.Button(root, text="Show var", command=lambda: print(radio_var.get()))
quitButton = ttk.Button(root, text="Exit", style="Red.TButton", command=exit)
for i, radio_button in enumerate(radio_buttons):
radio_button.grid(column=1, row=i, sticky="w")
showButton.grid(column=2, row=6, sticky="we", padx=6, pady=6)
quitButton.grid(column=2, row=7, sticky="we", padx=6, pady=6)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
style = ttk.Style()
style.theme_use("alt")
style.configure("Red.TButton", background="#ff8080")
radio_var = tkinter.StringVar()
radio_var.set("Python")
langs = ("Assembler", "Basic", "Brainfuck", "C", "Python")
radio_buttons = (
ttk.Radiobutton(root, text=lang, value=lang, variable=radio_var) for lang in langs
)
showButton = ttk.Button(root, text="Show var", command=lambda: print(radio_var.get()))
quitButton = ttk.Button(root, text="Exit", style="Red.TButton", command=exit)
for radio_button in radio_buttons:
radio_button.pack(fill="x")
showButton.pack()
quitButton.pack()
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
langs = ("Assembler", "Basic", "Brainfuck", "C", "Python")
listbox = tkinter.Listbox(root)
for lang in langs:
listbox.insert(tkinter.END, lang)
quitButton = ttk.Button(root, text="Exit", command=exit)
listbox.pack()
quitButton.pack()
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
langs = ("Assembler", "Basic", "Brainfuck", "C", "Python")
listbox = tkinter.Listbox(root)
for lang in langs:
listbox.insert(tkinter.END, lang)
def on_listbox_select(event):
index = listbox.curselection()[0]
global langs
print(langs[index])
listbox.bind("<<ListboxSelect>>", on_listbox_select)
quitButton = ttk.Button(root, text="Exit", command=exit)
listbox.pack()
quitButton.pack()
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
scrollbar = tkinter.Scrollbar(root)
langs = (
"Assembler",
"Basic",
"Brainfuck",
"C",
"C++",
"Java",
"Julia",
"Perl",
"Python",
)
listbox = tkinter.Listbox(root, height=4)
for lang in langs:
listbox.insert(tkinter.END, lang)
def on_listbox_select(event):
index = listbox.curselection()[0]
global langs
print(langs[index])
listbox.bind("<<ListboxSelect>>", on_listbox_select)
quitButton = ttk.Button(root, text="Exit", command=exit)
listbox.grid(column=1, row=1, sticky="nswe")
scrollbar.grid(column=2, row=1, sticky="ns")
quitButton.grid(column=1, row=2)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
scrollbar = ttk.Scrollbar(root)
langs = (
"Assembler",
"Basic",
"Brainfuck",
"C",
"C++",
"Java",
"Julia",
"Perl",
"Python",
)
listbox = tkinter.Listbox(root, yscrollcommand=scrollbar.set, height=4)
scrollbar.config(command=listbox.yview)
for lang in langs:
listbox.insert(tkinter.END, lang)
def on_listbox_select(event):
index = listbox.curselection()[0]
global langs
print(langs[index])
listbox.bind("<<ListboxSelect>>", on_listbox_select)
quitButton = ttk.Button(root, text="Exit", command=exit)
listbox.grid(column=1, row=1, sticky="nswe")
scrollbar.grid(column=2, row=1, sticky="ns")
quitButton.grid(column=1, row=2)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
number = tkinter.IntVar()
spinbox = tkinter.Spinbox(root, from_=100, to=120, width=10, textvariable=number)
showButton = ttk.Button(root, text="Show var", command=lambda: print(number.get()))
quitButton = ttk.Button(root, text="Exit", command=exit)
spinbox.grid(column=1, row=1)
showButton.grid(column=1, row=2)
quitButton.grid(column=2, row=2)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
selected_lang = tkinter.StringVar()
langs = (
"Assembler",
"Basic",
"Brainfuck",
"C",
"C++",
"Java",
"Julia",
"Perl",
"Python",
)
spinbox = tkinter.Spinbox(
root, values=langs, width=10, textvariable=selected_lang, wrap=True
)
showButton = ttk.Button(
root, text="Show var", command=lambda: print(selected_lang.get())
)
quitButton = ttk.Button(root, text="Exit", command=exit)
spinbox.grid(column=1, row=1)
showButton.grid(column=1, row=2)
quitButton.grid(column=2, row=2)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
style = ttk.Style()
style.theme_use("alt")
style.configure("Red.TButton", background="#ff8080")
radio_var = tkinter.StringVar()
radio_var.set("Python")
langs = ("Assembler", "Basic", "Brainfuck", "C", "Python")
f1 = ttk.Frame(root)
f2 = ttk.Frame(root)
radio_buttons = (
ttk.Radiobutton(f1, text=lang, value=lang, variable=radio_var) for lang in langs
)
showButton = ttk.Button(f2, text="Show var", command=lambda: print(radio_var.get()))
quitButton = ttk.Button(f2, text="Exit", style="Red.TButton", command=exit)
for i, radio_button in enumerate(radio_buttons):
radio_button.grid(column=1, row=i, sticky="w")
showButton.grid(column=1, row=1, sticky="we", padx=6, pady=6)
quitButton.grid(column=1, row=2, sticky="we", padx=6, pady=6)
f1.grid(column=1, row=1, sticky="ne", padx=6, pady=6)
f2.grid(column=2, row=1, sticky="ne", padx=6, pady=6)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
root = tkinter.Tk()
style = ttk.Style()
style.theme_use("alt")
style.configure("Red.TButton", background="#ff8080")
radio_var = tkinter.StringVar()
radio_var.set("Python")
langs = ("Assembler", "Basic", "Brainfuck", "C", "Python")
f1 = ttk.LabelFrame(root, text="Languages")
f2 = ttk.LabelFrame(root, text="Commands")
radio_buttons = (
ttk.Radiobutton(f1, text=lang, value=lang, variable=radio_var) for lang in langs
)
showButton = ttk.Button(f2, text="Show var", command=lambda: print(radio_var.get()))
quitButton = ttk.Button(f2, text="Exit", style="Red.TButton", command=exit)
for i, radio_button in enumerate(radio_buttons):
radio_button.grid(column=1, row=i, sticky="w")
showButton.grid(column=1, row=1, sticky="we", padx=6, pady=6)
quitButton.grid(column=1, row=2, sticky="we", padx=6, pady=6)
f1.grid(column=1, row=1, sticky="ne", padx=6, pady=6)
f2.grid(column=2, row=1, sticky="ne", padx=6, pady=6)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
def test():
print("Test!")
root = tkinter.Tk()
menubar = tkinter.Menu(root)
menubar.add_command(label="Test", command=test)
menubar.add_command(label="Quit", command=root.quit)
root.config(menu=menubar)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
def test():
print("Test!")
root = tkinter.Tk()
menubar = tkinter.Menu(root)
menubar.add_command(label="Test", command=test)
menubar.add_command(label="Quit", command=root.quit)
root.config(menu=menubar)
style = ttk.Style()
style.theme_use("alt")
style.configure("Red.TButton", background="#ff8080")
radio_var = tkinter.StringVar()
radio_var.set("Python")
langs = ("Assembler", "Basic", "Brainfuck", "C", "Python")
f1 = ttk.LabelFrame(root, text="Languages")
f2 = ttk.LabelFrame(root, text="Commands")
radio_buttons = (
ttk.Radiobutton(f1, text=lang, value=lang, variable=radio_var) for lang in langs
)
showButton = ttk.Button(f2, text="Show var", command=lambda: print(radio_var.get()))
quitButton = ttk.Button(f2, text="Exit", style="Red.TButton", command=root.quit)
for i, radio_button in enumerate(radio_buttons):
radio_button.grid(column=1, row=i, sticky="w")
showButton.grid(column=1, row=1, sticky="we", padx=6, pady=6)
quitButton.grid(column=1, row=2, sticky="we", padx=6, pady=6)
f1.grid(column=1, row=1, sticky="ne", padx=6, pady=6)
f2.grid(column=2, row=1, sticky="ne", padx=6, pady=6)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
def test():
print("Test!")
root = tkinter.Tk()
popup = tkinter.Menu(root, tearoff=0)
popup.add_command(label="Open")
popup.add_command(label="Save")
popup.add_separator()
popup.add_command(label="Exit", command=root.quit)
def on_popup(event):
popup.post(event.x_root - 5, event.y_root - 5)
root.bind("<Button-3>", on_popup)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
def test():
print("Test!")
root = tkinter.Tk()
menubar = tkinter.Menu(root)
filemenu = tkinter.Menu(menubar)
filemenu.add_command(label="Open")
filemenu.add_command(label="Save")
filemenu.add_separator()
filemenu.add_command(label="Exit", command=root.quit)
menubar.add_cascade(label="File", menu=filemenu)
editmenu = tkinter.Menu(menubar)
editmenu.add_command(label="Undo")
editmenu.add_separator()
editmenu.add_command(label="Cut")
editmenu.add_command(label="Copy")
editmenu.add_command(label="Paste")
editmenu.add_command(label="Delete")
editmenu.add_separator()
editmenu.add_command(label="Select All")
menubar.add_cascade(label="Edit", menu=editmenu)
helpmenu = tkinter.Menu(menubar)
helpmenu.add_command(label="About", command=test)
menubar.add_cascade(label="Help", menu=helpmenu)
root.config(menu=menubar)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
def test():
print("Test!")
root = tkinter.Tk()
menubar = tkinter.Menu(root)
root.option_add("*tearOff", False)
filemenu = tkinter.Menu(menubar)
filemenu.add_command(label="Open")
filemenu.add_command(label="Save")
filemenu.add_separator()
filemenu.add_command(label="Exit", command=root.quit)
menubar.add_cascade(label="File", menu=filemenu)
editmenu = tkinter.Menu(menubar)
editmenu.add_command(label="Undo")
editmenu.add_separator()
editmenu.add_command(label="Cut")
editmenu.add_command(label="Copy")
editmenu.add_command(label="Paste")
editmenu.add_command(label="Delete")
editmenu.add_separator()
editmenu.add_command(label="Select All")
menubar.add_cascade(label="Edit", menu=editmenu)
helpmenu = tkinter.Menu(menubar)
helpmenu.add_command(label="About", command=test)
menubar.add_cascade(label="Help", menu=helpmenu)
root.config(menu=menubar)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
def test():
print("Test!")
root = tkinter.Tk()
menubar = tkinter.Menu(root)
filemenu = tkinter.Menu(menubar, tearoff=0)
filemenu.add_command(label="Open")
filemenu.add_command(label="Save")
filemenu.add_separator()
filemenu.add_command(label="Exit", command=root.quit)
menubar.add_cascade(label="File", menu=filemenu)
editmenu = tkinter.Menu(menubar)
editmenu.add_command(label="Undo")
editmenu.add_separator()
editmenu.add_command(label="Cut")
editmenu.add_command(label="Copy")
editmenu.add_command(label="Paste")
editmenu.add_command(label="Delete")
editmenu.add_separator()
editmenu.add_command(label="Select All")
menubar.add_cascade(label="Edit", menu=editmenu)
helpmenu = tkinter.Menu(menubar, tearoff=0)
helpmenu.add_command(label="About", command=test)
menubar.add_cascade(label="Help", menu=helpmenu)
root.config(menu=menubar)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
def test():
print("Test!")
root = tkinter.Tk()
menubar = tkinter.Menu(root)
filemenu = tkinter.Menu(menubar, tearoff=0)
filemenu.add_command(label="Open")
filemenu.add_command(label="Save")
filemenu.add_separator()
filemenu.add_command(label="Exit", command=root.quit)
menubar.add_cascade(label="File", menu=filemenu)
editmenu = tkinter.Menu(menubar, tearoff=0)
editmenu.add_command(label="Undo")
editmenu.add_separator()
editmenu.add_command(label="Cut")
editmenu.add_command(label="Copy")
editmenu.add_command(label="Paste")
editmenu.add_command(label="Delete")
editmenu.add_separator()
editmenu.add_command(label="Select All")
menubar.add_cascade(label="Edit", menu=editmenu)
colors = ("white", "yellow", "orange", "red", "magenta", "blue", "cyan", "green")
colormenu = tkinter.Menu(menubar, tearoff=0)
for color in colors:
colormenu.add_command(label=color, background=color)
menubar.add_cascade(label="Colors", menu=colormenu)
helpmenu = tkinter.Menu(menubar, tearoff=0)
helpmenu.add_command(label="About", command=test)
menubar.add_cascade(label="Help", menu=helpmenu)
root.config(menu=menubar)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
def test():
print("Test!")
root = tkinter.Tk()
menubar = tkinter.Menu(root)
filemenu = tkinter.Menu(menubar, tearoff=0)
filemenu.add_command(label="Open", underline=0)
filemenu.add_command(label="Save", underline=0)
filemenu.add_separator()
filemenu.add_command(label="Exit", underline=1, command=root.quit)
menubar.add_cascade(label="File", menu=filemenu, underline=0)
editmenu = tkinter.Menu(menubar, tearoff=0)
editmenu.add_command(label="Undo", underline=0)
editmenu.add_separator()
editmenu.add_command(label="Cut", underline=2)
editmenu.add_command(label="Copy", underline=0)
editmenu.add_command(label="Paste", underline=0)
editmenu.add_command(label="Delete", underline=2)
editmenu.add_separator()
editmenu.add_command(label="Select All", underline=7)
menubar.add_cascade(label="Edit", menu=editmenu, underline=0)
colors = ("white", "yellow", "orange", "red", "magenta", "blue", "cyan", "green")
colormenu = tkinter.Menu(menubar, tearoff=0)
for color in colors:
colormenu.add_command(label=color, background=color)
menubar.add_cascade(label="Colors", menu=colormenu, underline=0)
helpmenu = tkinter.Menu(menubar, tearoff=0)
helpmenu.add_command(label="About", command=test, underline=0)
menubar.add_cascade(label="Help", menu=helpmenu, underline=0)
root.config(menu=menubar)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
def test():
print("Test!")
root = tkinter.Tk()
menubar = tkinter.Menu(root)
open_image = tkinter.PhotoImage(file="icons/document-open.gif")
save_image = tkinter.PhotoImage(file="icons/document-save.gif")
exit_image = tkinter.PhotoImage(file="icons/application-exit.gif")
undo_image = tkinter.PhotoImage(file="icons/edit-undo.gif")
cut_image = tkinter.PhotoImage(file="icons/edit-cut.gif")
copy_image = tkinter.PhotoImage(file="icons/edit-copy.gif")
paste_image = tkinter.PhotoImage(file="icons/edit-paste.gif")
delete_image = tkinter.PhotoImage(file="icons/edit-delete.gif")
select_all_image = tkinter.PhotoImage(file="icons/edit-select-all.gif")
filemenu = tkinter.Menu(menubar, tearoff=0)
filemenu.add_command(label="Open", underline=0, image=open_image, compound="left")
filemenu.add_command(label="Save", underline=0, image=save_image, compound="left")
filemenu.add_separator()
filemenu.add_command(
label="Exit", underline=1, image=exit_image, compound="left", command=root.quit
)
menubar.add_cascade(label="File", menu=filemenu, underline=0)
editmenu = tkinter.Menu(menubar, tearoff=0)
editmenu.add_command(label="Undo", underline=0, image=undo_image, compound="left")
editmenu.add_separator()
editmenu.add_command(label="Cut", underline=2, image=cut_image, compound="left")
editmenu.add_command(label="Copy", underline=0, image=copy_image, compound="left")
editmenu.add_command(label="Paste", underline=0, image=paste_image, compound="left")
editmenu.add_command(label="Delete", underline=2, image=delete_image, compound="left")
editmenu.add_separator()
editmenu.add_command(
label="Select All", underline=7, image=select_all_image, compound="left"
)
menubar.add_cascade(label="Edit", menu=editmenu, underline=0)
colors = ("white", "yellow", "orange", "red", "magenta", "blue", "cyan", "green")
colormenu = tkinter.Menu(menubar, tearoff=0)
for color in colors:
colormenu.add_command(label=color, background=color)
menubar.add_cascade(label="Colors", menu=colormenu, underline=0)
helpmenu = tkinter.Menu(menubar, tearoff=0)
helpmenu.add_command(label="About", command=test, underline=0)
menubar.add_cascade(label="Help", menu=helpmenu, underline=0)
root.config(menu=menubar)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
def test():
print("Test!")
root = tkinter.Tk()
menubar = tkinter.Menu(root)
image_names = [
"document-open",
"document-save",
"application-exit",
"edit-undo",
"edit-cut",
"edit-copy",
"edit-paste",
"edit-delete",
"edit-select-all",
]
images = {}
for image_name in image_names:
images[image_name] = tkinter.PhotoImage(file="icons/%s.gif" % image_name)
filemenu = tkinter.Menu(menubar, tearoff=0)
filemenu.add_command(
label="Open", underline=0, image=images["document-open"], compound="left"
)
filemenu.add_command(
label="Save", underline=0, image=images["document-save"], compound="left"
)
filemenu.add_separator()
filemenu.add_command(
label="Exit",
underline=1,
image=images["application-exit"],
compound="left",
command=root.quit,
)
menubar.add_cascade(label="File", menu=filemenu, underline=0)
editmenu = tkinter.Menu(menubar, tearoff=0)
editmenu.add_command(
label="Undo", underline=0, image=images["edit-undo"], compound="left"
)
editmenu.add_separator()
editmenu.add_command(
label="Cut", underline=2, image=images["edit-cut"], compound="left"
)
editmenu.add_command(
label="Copy", underline=0, image=images["edit-copy"], compound="left"
)
editmenu.add_command(
label="Paste", underline=0, image=images["edit-paste"], compound="left"
)
editmenu.add_command(
label="Delete", underline=2, image=images["edit-delete"], compound="left"
)
editmenu.add_separator()
editmenu.add_command(
label="Select All", underline=7, image=images["edit-select-all"], compound="left"
)
menubar.add_cascade(label="Edit", menu=editmenu, underline=0)
colors = ("white", "yellow", "orange", "red", "magenta", "blue", "cyan", "green")
colormenu = tkinter.Menu(menubar, tearoff=0)
for color in colors:
colormenu.add_command(label=color, background=color)
menubar.add_cascade(label="Colors", menu=colormenu, underline=0)
helpmenu = tkinter.Menu(menubar, tearoff=0)
helpmenu.add_command(label="About", command=test, underline=0)
menubar.add_cascade(label="Help", menu=helpmenu, underline=0)
root.config(menu=menubar)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
def test():
print("Test!")
root = tkinter.Tk()
menubar = tkinter.Menu(root)
image_names = [
"document-open",
"document-save",
"application-exit",
"edit-undo",
"edit-cut",
"edit-copy",
"edit-paste",
"edit-delete",
"edit-select-all",
]
images = {}
for image_name in image_names:
images[image_name] = tkinter.PhotoImage(file="icons/%s.gif" % image_name)
filemenu = tkinter.Menu(menubar, tearoff=0)
filemenu.add_command(
label="Open", underline=0, image=images["document-open"], compound="left"
)
filemenu.add_command(
label="Save", underline=0, image=images["document-save"], compound="left"
)
filemenu.add_separator()
filemenu.add_command(
label="Exit",
underline=1,
image=images["application-exit"],
compound="left",
command=root.quit,
)
menubar.add_cascade(label="File", menu=filemenu, underline=0)
editmenu = tkinter.Menu(menubar, tearoff=0)
editmenu.add_command(
label="Undo", underline=0, image=images["edit-undo"], compound="left"
)
editmenu.add_separator()
editmenu.add_command(
label="Cut", underline=2, image=images["edit-cut"], compound="left"
)
editmenu.add_command(
label="Copy", underline=0, image=images["edit-copy"], compound="left"
)
editmenu.add_command(
label="Paste", underline=0, image=images["edit-paste"], compound="left"
)
editmenu.add_command(
label="Delete", underline=2, image=images["edit-delete"], compound="left"
)
editmenu.add_separator()
editmenu.add_command(
label="Select All", underline=7, image=images["edit-select-all"], compound="left"
)
menubar.add_cascade(label="Edit", menu=editmenu, underline=0)
word_wrap = tkinter.BooleanVar()
show_all = tkinter.BooleanVar()
show_all.set(True)
optionmenu = tkinter.Menu(menubar, tearoff=0)
optionmenu.add_checkbutton(
label="Word wrap", onvalue=True, offvalue=False, variable=word_wrap
)
optionmenu.add_checkbutton(
label="Show all", onvalue=True, offvalue=False, variable=show_all
)
menubar.add_cascade(label="Options", menu=optionmenu, underline=0)
colors = ("white", "yellow", "orange", "red", "magenta", "blue", "cyan", "green")
colormenu = tkinter.Menu(menubar, tearoff=0)
for color in colors:
colormenu.add_command(label=color, background=color)
menubar.add_cascade(label="Colors", menu=colormenu, underline=0)
helpmenu = tkinter.Menu(menubar, tearoff=0)
helpmenu.add_command(label="About", command=test, underline=0)
menubar.add_cascade(label="Help", menu=helpmenu, underline=0)
root.config(menu=menubar)
root.geometry("320x200")
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
def test():
print("Test!")
root = tkinter.Tk()
menubar = tkinter.Menu(root)
image_names = [
"document-open",
"document-save",
"application-exit",
"edit-undo",
"edit-cut",
"edit-copy",
"edit-paste",
"edit-delete",
"edit-select-all",
]
images = {}
for image_name in image_names:
images[image_name] = tkinter.PhotoImage(file="icons/%s.gif" % image_name)
filemenu = tkinter.Menu(menubar, tearoff=0)
filemenu.add_command(
label="Open", underline=0, image=images["document-open"], compound="left"
)
filemenu.add_command(
label="Save", underline=0, image=images["document-save"], compound="left"
)
filemenu.add_separator()
filemenu.add_command(
label="Exit",
underline=1,
image=images["application-exit"],
compound="left",
command=root.quit,
)
menubar.add_cascade(label="File", menu=filemenu, underline=0)
editmenu = tkinter.Menu(menubar, tearoff=0)
editmenu.add_command(
label="Undo", underline=0, image=images["edit-undo"], compound="left"
)
editmenu.add_separator()
editmenu.add_command(
label="Cut", underline=2, image=images["edit-cut"], compound="left"
)
editmenu.add_command(
label="Copy", underline=0, image=images["edit-copy"], compound="left"
)
editmenu.add_command(
label="Paste", underline=0, image=images["edit-paste"], compound="left"
)
editmenu.add_command(
label="Delete", underline=2, image=images["edit-delete"], compound="left"
)
editmenu.add_separator()
editmenu.add_command(
label="Select All", underline=7, image=images["edit-select-all"], compound="left"
)
menubar.add_cascade(label="Edit", menu=editmenu, underline=0)
word_wrap = tkinter.BooleanVar()
show_all = tkinter.BooleanVar()
show_all.set(True)
optionmenu = tkinter.Menu(menubar, tearoff=0)
optionmenu.add_checkbutton(
label="Word wrap", onvalue=True, offvalue=False, variable=word_wrap
)
optionmenu.add_checkbutton(
label="Show all", onvalue=True, offvalue=False, variable=show_all
)
menubar.add_cascade(label="Options", menu=optionmenu, underline=0)
colors = ("white", "yellow", "orange", "red", "magenta", "blue", "cyan", "green")
colormenu = tkinter.Menu(menubar, tearoff=0)
for color in colors:
colormenu.add_radiobutton(label=color, background=color)
menubar.add_cascade(label="Colors", menu=colormenu, underline=0)
helpmenu = tkinter.Menu(menubar, tearoff=0)
helpmenu.add_command(label="About", command=test, underline=0)
menubar.add_cascade(label="Help", menu=helpmenu, underline=0)
root.config(menu=menubar)
root.geometry("320x200")
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
root = tkinter.Tk()
menubar = tkinter.Menu(root)
filemenu = tkinter.Menu(menubar, tearoff=0)
filemenu.add_command(
label="Open", underline=0, accelerator="Ctrl+O", command=lambda: print("Open")
)
filemenu.add_command(
label="Save", underline=0, accelerator="Ctrl+S", command=lambda: print("Save")
)
filemenu.add_separator()
filemenu.add_command(label="Exit", underline=1, accelerator="Ctrl+Q", command=root.quit)
menubar.add_cascade(label="File", menu=filemenu, underline=0)
editmenu = tkinter.Menu(menubar, tearoff=0)
editmenu.add_command(
label="Undo", underline=0, accelerator="Ctrl+U", command=lambda: print("Undo")
)
editmenu.add_separator()
editmenu.add_command(
label="Cut", underline=2, accelerator="Ctrl+X", command=lambda: print("Cut")
)
editmenu.add_command(
label="Copy", underline=0, accelerator="Ctrl+C", command=lambda: print("Copy")
)
editmenu.add_command(
label="Paste", underline=0, accelerator="Ctrl+V", command=lambda: print("Paste")
)
editmenu.add_command(label="Delete", underline=2, command=lambda: print("Delete"))
editmenu.add_separator()
editmenu.add_command(
label="Select All",
underline=7,
accelerator="Ctrl+A",
command=lambda: print("Select All"),
)
menubar.add_cascade(label="Edit", menu=editmenu, underline=0)
helpmenu = tkinter.Menu(menubar, tearoff=0)
helpmenu.add_command(
label="About", underline=0, accelerator="F1", command=lambda: print("About")
)
menubar.add_cascade(label="Help", menu=helpmenu, underline=0)
root.config(menu=menubar)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
def cmd_open():
print("Open")
def cmd_save():
print("Save")
def cmd_undo():
print("Undo")
def cmd_help():
print("Help")
root = tkinter.Tk()
menubar = tkinter.Menu(root)
filemenu = tkinter.Menu(menubar, tearoff=0)
filemenu.add_command(label="Open", underline=0, accelerator="Ctrl+O", command=cmd_open)
filemenu.add_command(label="Save", underline=0, accelerator="Ctrl+S", command=cmd_save)
filemenu.add_separator()
filemenu.add_command(label="Exit", underline=1, accelerator="Ctrl+Q", command=root.quit)
menubar.add_cascade(label="File", menu=filemenu, underline=0)
editmenu = tkinter.Menu(menubar, tearoff=0)
editmenu.add_command(label="Undo", underline=0, accelerator="Ctrl+U", command=cmd_undo)
editmenu.add_separator()
editmenu.add_command(
label="Cut", underline=2, accelerator="Ctrl+X", command=lambda: print("Cut")
)
editmenu.add_command(
label="Copy", underline=0, accelerator="Ctrl+C", command=lambda: print("Copy")
)
editmenu.add_command(
label="Paste", underline=0, accelerator="Ctrl+V", command=lambda: print("Paste")
)
editmenu.add_command(label="Delete", underline=2, command=lambda: print("Delete"))
editmenu.add_separator()
editmenu.add_command(
label="Select All",
underline=7,
accelerator="Ctrl+A",
command=lambda: print("Select All"),
)
menubar.add_cascade(label="Edit", menu=editmenu, underline=0)
helpmenu = tkinter.Menu(menubar, tearoff=0)
helpmenu.add_command(label="About", underline=0, accelerator="F1", command=cmd_help)
menubar.add_cascade(label="Help", menu=helpmenu, underline=0)
root.config(menu=menubar)
root.bind("<Control-o>", lambda event: cmd_open())
root.bind("<Control-s>", lambda event: cmd_save())
root.bind("<Control-u>", lambda event: cmd_undo())
root.bind("<F1>", lambda event: cmd_help())
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
root = tkinter.Tk()
canvas = tkinter.Canvas(root, width=256, height=256)
canvas.pack()
canvas.create_oval(10, 10, 100, 100)
canvas.create_line(0, 0, 255, 255)
canvas.create_line(0, 255, 255, 0)
canvas.create_text(50, 120, text="Hello world!")
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
root = tkinter.Tk()
canvas = tkinter.Canvas(root, width=256, height=256)
canvas.pack()
canvas.create_oval(10, 10, 100, 100, fill="red", outline="blue", width=3)
canvas.create_line(0, 0, 255, 255, width=5)
canvas.create_line(0, 255, 255, 0, dash=123)
canvas.create_text(150, 120, text="Hello world!", fill="white", font="Helvetica 20")
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
import sys
WIDTH = 400
HEIGHT = 400
GRID_SIZE = 100
def exit():
sys.exit(0)
def basic_canvas(root, width, height, grid_size):
canvas = tkinter.Canvas(root, width=width, height=height, background="#ccffcc")
canvas.pack()
draw_grid(canvas, width, height, grid_size)
return canvas
def draw_grid(canvas, width, height, grid_size):
for x in range(0, width, grid_size):
canvas.create_line(x, 0, x, height, dash=7, fill="gray")
for y in range(0, height, grid_size):
canvas.create_line(0, y, width, y, dash=7, fill="gray")
root = tkinter.Tk()
canvas = basic_canvas(root, WIDTH, HEIGHT, GRID_SIZE)
canvas.create_line(0, 0, 100, 100, fill="red", width=2, dash=8)
canvas.create_arc(
100, 1, 200, 100, outline="blue", start=45, extent=180, style=tkinter.ARC, width=2
)
canvas.create_oval(200, 1, 300, 100)
canvas.create_oval(325, 25, 375, 75, fill="#a0a0ff")
canvas.create_rectangle(50, 125, 150, 175, fill="#a0a0ff")
canvas.create_text(300, 150, text="Hello world!", font="Helvetica 20")
canvas.create_polygon(50, 225, 200, 300, 50, 375, fill="#80ff80")
canvas.create_polygon(
250, 225, 400, 300, 250, 375, fill="black", outline="red", width="5"
)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
from tkinter import messagebox
import sys
def exit():
sys.exit(0)
root = tkinter.Tk()
infoButton = tkinter.Button(
root, text="Info box", command=lambda: messagebox.showinfo("Title", "Text")
)
warningButton = tkinter.Button(
root, text="Warning box", command=lambda: messagebox.showwarning("Title", "Text")
)
errorButton = tkinter.Button(
root, text="Error box", command=lambda: messagebox.showerror("Title", "Text")
)
quitButton = tkinter.Button(root, text="Exit", command=exit)
infoButton.pack(fill=tkinter.BOTH)
warningButton.pack(fill=tkinter.BOTH)
errorButton.pack(fill=tkinter.BOTH)
tkinter.Label(text="").pack()
quitButton.pack(fill=tkinter.BOTH)
root.mainloop()
#!/usr/bin/env python
# vim: set fileencoding=utf-8
import tkinter
from tkinter import ttk
from tkinter import messagebox
import sys
def exit():
sys.exit(0)
def showOkCancelMessageBox():
print(
messagebox.askokcancel(
"Otázečka na závěr", "Skutečně, ale skutečně ukončit program?"
)
)
def showRetryCancelMessageBox():
print(messagebox.askretrycancel("Chyba při tisku", "Opakovat tisk?"))
def showYesNoMessageBox():
print(
messagebox.askyesno(
"Otázečka na závěr", "Skutečně, ale skutečně ukončit program?"
)
)
def showQuestionMessageBox():
print(messagebox.askquestion("Otázečka na závěr", "Provést zálohu?"))
root = tkinter.Tk()
showOkCancelButton = tkinter.Button(
root, text="Show Ok/Cancel message box", command=showOkCancelMessageBox
)
showRetryCancelButton = tkinter.Button(
root, text="Show Retry/Cancel box", command=showRetryCancelMessageBox
)
showYesNoButton = tkinter.Button(
root, text="Show Yes.No box", command=showYesNoMessageBox
)
showQuestionButton = tkinter.Button(
root, text="Show question box", command=showQuestionMessageBox
)
quitButton = tkinter.Button(root, text="Exit", command=exit)
showOkCancelButton.pack(fill=tkinter.BOTH)
showRetryCancelButton.pack(fill=tkinter.BOTH)
showYesNoButton.pack(fill=tkinter.BOTH)
showQuestionButton.pack(fill=tkinter.BOTH)
tkinter.Label(text="").pack()
quitButton.pack(fill=tkinter.BOTH)
root.mainloop()
#!/usr/bin/python
# -*- coding: utf-8 -*-
import tkinter
import time
# width of the animation window
animation_window_width = 800
# height of the animation window
animation_window_height = 600
# initial x position of the ball
animation_ball_start_xpos = 50
# initial y position of the ball
animation_ball_start_ypos = 50
# radius of the ball
animation_ball_radius = 30
# the pixel movement of ball for each iteration
animation_ball_min_movement = 5
# delay between successive frames in seconds
animation_refresh_seconds = 0.01
# The main window of the animation
def create_animation_window():
window = tkinter.Tk()
window.title("Tkinter Animation Demo")
# Uses python 3.6+ string interpolation
window.geometry(f"{animation_window_width}x{animation_window_height}")
return window
# Create a canvas for animation and add it to main window
def create_animation_canvas(window):
canvas = tkinter.Canvas(window)
canvas.configure(bg="white")
canvas.pack(fill="both", expand=True)
return canvas
# Create and animate ball in an infinite loop
def animate_ball(window, canvas, xinc, yinc):
ball = canvas.create_oval(
animation_ball_start_xpos - animation_ball_radius,
animation_ball_start_ypos - animation_ball_radius,
animation_ball_start_xpos + animation_ball_radius,
animation_ball_start_ypos + animation_ball_radius,
fill="darkblue",
outline="blue",
width=4,
)
while True:
canvas.move(ball, xinc, yinc)
window.update()
time.sleep(animation_refresh_seconds)
ball_pos = canvas.coords(ball)
# unpack array to variables
(xl, yl, xr, yr) = ball_pos
if xl < abs(xinc) or xr > animation_window_width - abs(xinc):
xinc = -xinc
if yl < abs(yinc) or yr > animation_window_height - abs(yinc):
yinc = -yinc
# The actual execution starts here
animation_window = create_animation_window()
animation_canvas = create_animation_canvas(animation_window)
animate_ball(
animation_window,
animation_canvas,
animation_ball_min_movement,
animation_ball_min_movement,
)
–
# Třídní atributy jsou de facto uloženy ve slovníku
# Ve skutečnosti B a C nemají vlastní hodnoty atributů
# pouze reference do A
class A(object):
attribute = "foo"
class B(A):
pass
class C(A):
pass
print(A.attribute, B.attribute, C.attribute)
A.attribute = "baz"
print(A.attribute, B.attribute, C.attribute)
# výchozí hodnota funkce je vyhodnocena pouze jedenkrát
# a to ve chvíli definici funkce
def foo(bar=[]):
bar.append("baz")
return bar
print(foo())
print(foo())
print(foo())
# výchozí hodnota funkce je vyhodnocena pouze jedenkrát
# a to ve chvíli definici funkce
def foo(bar=None):
if bar is None:
bar = []
bar.append("baz")
return bar
print(foo())
print(foo())
print(foo())
x = 1
def foo():
x += 1
print(x)
foo()
x = 1
def foo():
global x
x += 1
print(x)
foo()
seznam = []
def foo(x):
seznam.append(x)
print(seznam)
foo(1)
print(seznam)
foo(2)
print(seznam)
def bar(x):
seznam += [x]
print(seznam)
bar(3)
print(seznam)
bar(4)
print(seznam)
seznam = []
def foo(x):
seznam.append(x)
print(seznam)
foo(1)
print(seznam)
foo(2)
print(seznam)
def bar(x):
global seznam
seznam += [x]
print(seznam)
bar(3)
print(seznam)
bar(4)
print(seznam)
y = 10
def adder(x):
return y + x
print(adder(1))
y = 20
print(adder(1))
# Python 2 vs Python 3
x = 0.2
x += 0.1
print(x)
print(repr(x))
print(str(x))
numbers = [n for n in range(10)]
print(numbers)
for i in range(len(numbers)):
print(i)
if numbers[i] % 2 == 0:
del numbers[i]
print(numbers)
–