Test Automation – Software testing made easy!

Python

Operatory porównania: „is” kontra „==”

Autor wpisu Autor: Piotr Maziak
Data wpisu 27 grudnia, 2019

Jaka jest różnica pomiędzy == oraz is. Zróbmy mały teścik.


a = [ x for x in range(4) ]
b = a
print(a,b)
b[0] = 2
print(a, b) 
c = list(a)
print(a, b, c)
print(f"a={a} address={hex(id(a))} repr={a.__repr__}")
print(f"b={b} address={hex(id(b))} repr={b.__repr__}")
print(f"c={c} address={hex(id(c))} repr={c.__repr__}")

print(a is b)
print(a == b)
print(a == c)
print(c is a)

a = [ x for x in range(4) ]

b = a

print(a,b)

b[0] = 2

print(a, b)

c = list(a)

print(a, b, c)

print(f"a={a} address={hex(id(a))} repr={a.__repr__}")

print(f"b={b} address={hex(id(b))} repr={b.__repr__}")

print(f"c={c} address={hex(id(c))} repr={c.__repr__}")

print(a is b)

print(a == b)

print(a == c)

print(c is a)

Wynik powyższego snippetu nie jest zaskakujący.


[0, 1, 2, 3] [0, 1, 2, 3]
[2, 1, 2, 3] [2, 1, 2, 3]
[2, 1, 2, 3] [2, 1, 2, 3] [2, 1, 2, 3]
a=[2, 1, 2, 3] address=0x7f439fae9788 repr=<method-wrapper '__repr__' of list object at 0x7f439fae9788>
b=[2, 1, 2, 3] address=0x7f439fae9788 repr=<method-wrapper '__repr__' of list object at 0x7f439fae9788>
c=[2, 1, 2, 3] address=0x7f439faf3608 repr=<method-wrapper '__repr__' of list object at 0x7f439faf3608>
True
True
True
False

[0, 1, 2, 3] [0, 1, 2, 3]

[2, 1, 2, 3] [2, 1, 2, 3]

[2, 1, 2, 3] [2, 1, 2, 3] [2, 1, 2, 3]

a=[2, 1, 2, 3] address=0x7f439fae9788 repr=<method-wrapper '__repr__' of list object at 0x7f439fae9788>

b=[2, 1, 2, 3] address=0x7f439fae9788 repr=<method-wrapper '__repr__' of list object at 0x7f439fae9788>

c=[2, 1, 2, 3] address=0x7f439faf3608 repr=<method-wrapper '__repr__' of list object at 0x7f439faf3608>

True

False

b i a wskazują na ten sam obiekt w pamięci, zatem każda zmiana w a lub b dokonywana jest na tym samym obiekcie. Dlatego też a is b oraz a == b zwracają True.

Lista c jest nowym obiektem stworzonym z kopii a. Wskazuje na inny obszar pamięci zatem a is c zwraca False. Ponieważ a i c mają taka samą zawartość a == c zwraca True. Podsumowując kolokwialnie można stwierdzić, że operator == sprawdza czy obiekty sa takie same, natomiast operator is czy obiekty są identyczne(lub czy obiekt jest tym samym obiektem).

Python

Parametry opcjonalne: *args, **kwargs

Autor wpisu Autor: Piotr Maziak
Data wpisu 26 grudnia, 2019

Funkcje napisane w języku Python mają możliwość akceptowania opcjonalnych parametrów. Przyjrzyjmy się poniższemu snippetowi.


def args_kwargs(*args, **kwargs):
    if args:
        print(args)
    if kwargs:
        print(kwargs)

def args_kwargs(*args, **kwargs):

if args:

print(args)

if kwargs:

print(kwargs)

Jeżeli wywołamy tę funkcję w następujący sposób:


args_kwargs(1, 2, '3', first='first', second='second', third='third')

args_kwargs(1, 2, '3', first='first', second='second', third='third')

Otrzymamy następujący wynik:


(1, 2, '3')
{'first': 'first', 'second': 'second', 'third': 'third'}

(1, 2, '3')

{'first': 'first', 'second': 'second', 'third': 'third'}

Argumenty pozycyjne zostały skumulowane w tuplu *args, a argumenty nazwane w słowniku **kwargs. Co się stanie gdy wywołamy tę funkcję bez argumentów:


args_kwargs()

args_kwargs()

Nic się nie wydarzyło, błędu też nie ma. Więc argumenty *args i **kwargs nie są wymagane. Dodajmy dodatkowy argument arg_1 i wywołajmy tę funkcję z poprzednimi argumentami.


def args_kwargs(arg_1, *args, **kwargs):
    if args:
        print(args)
    if kwargs:
        print(kwargs)

args_kwargs(1, 2, '3', first='first', second='second', third='third')

# (2, '3')
# {'first': 'first', 'second': 'second', 'third': 'third'}

def args_kwargs(arg_1, *args, **kwargs):

if args:

print(args)

if kwargs:

print(kwargs)

args_kwargs(1, 2, '3', first='first', second='second', third='third')

# (2, '3')

# {'first': 'first', 'second': 'second', 'third': 'third'}

Z tupla *args znikneła nam 1. Wypiszmy brakujący arg_1 i wywołajmy funkcję jeszcze raz.


def args_kwargs(arg_1, *args, **kwargs):
    print(f"arg_1 = {arg_1}")
    if args:
        print(args)
    if kwargs:
        print(kwargs)

args_kwargs(1, 2, '3', first='first', second='second', third='third')

# arg_1 = 1
# (2, '3')
# {'first': 'first', 'second': 'second', 'third': 'third'}

def args_kwargs(arg_1, *args, **kwargs):

print(f"arg_1 = {arg_1}")

if args:

print(args)

if kwargs:

print(kwargs)

args_kwargs(1, 2, '3', first='first', second='second', third='third')

# arg_1 = 1

# (2, '3')

# {'first': 'first', 'second': 'second', 'third': 'third'}

Co się stanie jak wywołamy funkcję bez argumentów?


args_kwargs()

Traceback (most recent call last):
  File "args_kwargs.py", line 2, in 
    args_kwargs()
TypeError: args_kwargs() missing 1 required positional argument: 'arg_1'

args_kwargs()

Traceback (most recent call last):

File "args_kwargs.py", line 2, in

args_kwargs()

TypeError: args_kwargs() missing 1 required positional argument: 'arg_1'

No tak arg_1 jest wymagany. Potestujmy tę funkcję i zobaczmy do jakich dojdziemy wniosków.


args_kwargs(1)
# arg_1 = 1

args_kwargs(1, first='first')
# arg_1 = 1
# {'first': 'first'}

args_kwargs(1, 1, 1)
# arg_1 = 1
# (1, 1)

args_kwargs(1, 1, second='second')
# arg_1 = 1
# (1,)
# {'second': 'second'}

args_kwargs(1, 1, second='second', 1)
# args_kwargs(1, 1, second='second', 1)
#                                   ^
# SyntaxError: positional argument follows keyword argument

args_kwargs(arg_1=1, 1, second='second')
# args_kwargs(arg_1=1, 1, second='second')
#                     ^
# SyntaxError: positional argument follows keyword argument

args_kwargs(1)

# arg_1 = 1

args_kwargs(1, first='first')

# arg_1 = 1

# {'first': 'first'}

args_kwargs(1, 1, 1)

# arg_1 = 1

# (1, 1)

args_kwargs(1, 1, second='second')

# arg_1 = 1

# (1,)

# {'second': 'second'}

args_kwargs(1, 1, second='second', 1)

# args_kwargs(1, 1, second='second', 1)

# ^

# SyntaxError: positional argument follows keyword argument

args_kwargs(arg_1=1, 1, second='second')

# args_kwargs(arg_1=1, 1, second='second')

# ^

# SyntaxError: positional argument follows keyword argument

A więc w Pythonie istotna jest kolejność argumentów pierwszy od lewej przypisany jest do arg_1 kolejne pozycyjne są umieszczane w tuplu *args a argumenty nazwane są kumulowane w słowniku **kwargs. Jeżeli odwrócimy w jakiś sposób kolejność argumentów zostanie zwrócony SyntaxError. Warto wspomnieć, że nazwy *args oraz **kwargs to tylko przyjęta konwencja równie dobrze możesz użyć *positional_arguments, **named_arguments. Ważne aby zapamiętać, że prefix * oznacza tuple a prefix ** słownik.

Bugi

Bug w module Makler Banku ING

Autor wpisu Autor: Piotr Maziak
Data wpisu 22 grudnia, 2019

Kupiłem pakiet akcji PGNIG (niestety jak były na górce). Posiadam konto maklerskie w Banku ING i często korzystam z modułu Makler. 23 grudnia 2019 to ostatni dzień w którym można „rozliczyć” bieżący rok, wiec podejrzewałem, że „ostatni będzie gasił światło”. W piątek 20 grudnia w dogrywce pojawiła sie bardzo duża tranzakcja ponad 15mln sztuk akcji czyli jakies ~63mln zł. Moduł Makler zwariował 🙂 Widget z tranzakcjami „sypał” tysiącem tranzakcji po 15mln sztuk a wykresy liniowy i świeczkowy miały błedne wartości.

Oczywiście zgłosiłem to do ING zobaczymy czy doczekam się odpowiedzi. W każdym bądź razie nie tak powinny działać widgety bankowości online

Bug w module Makler Banku ING

Bug w module Makler

Update: Otrzymałem info z biura maklerskiego, że zgłoszenie zostało przekazane specjalistom od oprogramowania.

Bugi

Bug w frameworku Qt

Autor wpisu Autor: Piotr Maziak
Data wpisu 22 grudnia, 2019

Niedawno znalazłem małego buga w frameworku Qt 5.13.0 w pluginie qtserialbus. W momencie gdy klient wysyłał sygnał disconnect do serwera, serwer nie obsługiwał tego sygnału a więc client tak naprawdę nie był rozłączany. W następstwie tego każda kolejna próba połączenia kończyła się niepowodzeniem. Zgłosiłem znajdkę autorowi pluginu i po małej wymianie mejli otrzymałem taką odpowiedż

Hi Piotr

thanks again for your report.

I was finally able to reproduce it. The reason there is no problem with the CAN example is, that there the device is not properly disconnected but rather deleted. Every new connection creates a new device so I didn’t see your bug.

Anyway, the fix is here:

https://codereview.qt-project.org/c/qt/qtserialbus/+/280863

It will go into Qt 5.14.0 hopefully, which is expected quite soon.

If you could test the patch on your machine (by building qtserialbus from source) or at least the next 5.14 snapshot after the patch is merged, that would be super helpful.

Thanks and best regards,

Andre

Nieskromnie się tym chwalę 🙂

Python

Lambda : Anonimowe funkcje w Pythonie

Autor wpisu Autor: Piotr Maziak
Data wpisu 22 grudnia, 2019

W języku Python lambda jest słowem kluczowym dzięki któremu możemy deklarować funkcje anonimowe. W poprzednich wpisach wykorzystałem domknięcia i callable do obliczania potęgi, w przypadku lambdy może to wyglądać tak


power = lambda b, e: b ** e
print(power(2,2))
# 4

power = lambda b, e: b ** e

print(power(2,2))

# 4

Lambdy można domknąć


def power_of(base):
    return lambda exponent: base ** exponent

power_of_two = power_of(2)
print(power_of_two(3))
# 8

def power_of(base):

return lambda exponent: base ** exponent

power_of_two = power_of(2)

print(power_of_two(3))

# 8

Lambda możne również zwrócić lambdę. Jest to karkołomna konstrukcja ale jak najbardziej prawidłowo działająca


power = lambda base : lambda exponent: base ** exponent
print(power(3)(2))
# 9

power = lambda base : lambda exponent: base ** exponent

print(power(3)(2))

# 9

Kiedy stosować lambdę? Np. w metodach map, filter, reduce i innych przyjmujących funkcję lub wtedy gdy tą funkcję wykonujemy tylko raz.

Python

Callable: Obiekt który zachowuje się jak funkcja

Autor wpisu Autor: Piotr Maziak
Data wpisu 21 grudnia, 2019

W języku Python wszystkie funkcje są obiektami, ale na odwrót już nie. Jednak Python oferuje nam możliwość traktowania obiektów jak funkcję. Aby instancja klasy stała się takim obiektem wystarczy stworzyć metodę __call__. W poprzednim wpisie pokazałem jak wykorzystać domknięcie do obliczenia potęgi danej liczby. Tym razem, do tego samego celu użyjemy obiektu callable.


class Power_of():
    def __init__(self, base):
        self.base = base

    def __call__(self, exponent):
        return self.base ** exponent

class Power_of():

def __init__(self, base):

self.base = base

def __call__(self, exponent):

return self.base ** exponent

A teraz stworzymy kilka obiektów i wywołamy je jako funkcje.


power_of_two = Power_of(2)
power_of_three = Power_of(3)
power_of_four = Power_of(4)

print(power_of_two(0))
print(power_of_two(1))
print(power_of_two(2))

print(power_of_three(0))
print(power_of_three(1))
print(power_of_three(2))

print(power_of_four(0))
print(power_of_four(1))
print(power_of_four(2))
# 1
# 2
# 4
# 1
# 3
# 9
# 1
# 4
# 16

power_of_two = Power_of(2)

power_of_three = Power_of(3)

power_of_four = Power_of(4)

print(power_of_two(0))

print(power_of_two(1))

print(power_of_two(2))

print(power_of_three(0))

print(power_of_three(1))

print(power_of_three(2))

print(power_of_four(0))

print(power_of_four(1))

print(power_of_four(2))

# 1

# 2

# 4

# 1

# 3

# 9

# 1

# 4

# 16

Elegancko ! Mamy teraz obiekt który możemy wywoływać jak funkcję. Zapraszam Cię do porównania dzisiejszego postu z poprzednim wpisem

Python

Closures: domknięcia leksykalne

Autor wpisu Autor: Piotr Maziak
Data wpisu 20 grudnia, 2019

Przyjrzyjmy się poniższemu snieppetowi. Funkcja power_of zwraca nam wewnętrzną funkcję power


def power_of(base):
    def power(exponent):
        return base ** exponent
    return power

def power_of(base):

def power(exponent):

return base ** exponent

return power

Zagnieżdżona funkcja power nie posiada parametru base zdefiniowanego przez funkcję nadrzędną. Jednak w jakiś sposób ma do tego argumentu dostęp. Wywołajmy tą funkcję i zobaczmy co się stanie


power_of_two = power_of(2)
power_of_three = power_of(3)
power_of_four = power_of(4)

print(power_of_two(4))
print(power_of_three(4))
print(power_of_four(4))
# 16
# 81
# 256

power_of_two = power_of(2)

power_of_three = power_of(3)

power_of_four = power_of(4)

print(power_of_two(4))

print(power_of_three(4))

print(power_of_four(4))

# 16

# 81

# 256

MAGIC!!. W jakiś sposób funkcja power pamięta wartość argumentu przekazanego do funkcji nadrzędnej. Odpowiada za to tzw. domknięcie (ang. lexical closures). W chwili gdy funkcje power_of… były deklarowane, domknięcie zapamietało środowisko leksykalne w jakim były one tworzone.
Odpowiednikiem powyższych domknięć mogą być następujące funkcje:


def power_of_two(exponent):
    return 2 ** exponent

def power_of_three(exponent):
    return 3 ** exponent

def power_of_four(exponent):
    return 4 ** exponent

def power_of_two(exponent):

return 2 ** exponent

def power_of_three(exponent):

return 3 ** exponent

def power_of_four(exponent):

return 4 ** exponent

Jak widzisz dzięki domknięciom możemy pre-konfigurować zachowanie funkcji, oszczędzić czas i ilość kodu, a im mniej kodu tym mniej błedów 🙂

Python

Sortowanie listy słowników po kluczu który może nie istnieć.

Autor wpisu Autor: Piotr Maziak
Data wpisu 18 grudnia, 2019

Przypuśćmy, że chcielibyśmy posortować listę słowników wg klucza. Jeżeli mamy szczęście i dany klucz występuje we wszystkich słownikach zadanie jest proste.


dictionaries = [{"first" : 5},
                {"first" : 3},
                {"first" : 2},
                {"first" : 2},
                {"first" : 1},
                {"first" : 1},]

print(sorted(dictionaries, key=lambda x: x["first"]))

dictionaries = [{"first" : 5},

{"first" : 3},

{"first" : 2},

{"first" : 1},

{"first" : 1},]

print(sorted(dictionaries, key=lambda x: x["first"]))

W rezultacie otrzymujemy


[{'first': 1}, {'first': 1}, {'first': 2}, {'first': 2}, {'first': 3}, {'first': 5}]

[{'first': 1}, {'first': 1}, {'first': 2}, {'first': 2}, {'first': 3}, {'first': 5}]

Niestety powyższy snippet nie działa gdy w naszym słowniku nie ma danego klucza. jak zapewne wiesz w takim wypadku interpreter podniesie wyjątek KeyError


dictionaries = [
                {"first" : 5},
                {"first" : 3},
                {"second" : 2},
                {"first" : 2},
                {"first" : 1},
                {"first" : 1},]

print(sorted(dictionaries, key=lambda x: x["first"]))

dictionaries = [

{"first" : 5},

{"first" : 3},

{"second" : 2},

{"first" : 2},

{"first" : 1},

{"first" : 1},]

print(sorted(dictionaries, key=lambda x: x["first"]))

Wynik


Traceback (most recent call last):
  File "dictionary_sorting.py", line 10, in 
    print(sorted(dictionaries, key=lambda x: x["first"]))
  File "dictionary_sorting.py", line 10, in 
    print(sorted(dictionaries, key=lambda x: x["first"]))
KeyError: 'first'

Traceback (most recent call last):

File "dictionary_sorting.py", line 10, in

print(sorted(dictionaries, key=lambda x: x["first"]))

File "dictionary_sorting.py", line 10, in

print(sorted(dictionaries, key=lambda x: x["first"]))

KeyError: 'first'

Najprostrzym rozwiązaniem tego problemu jest użycie metody get(). W przypadku braku klucza nie podniesie wyjątku tylko zwróci None


dictionaries = [
                {"first" : 5},
                {"first" : 3},
                {"second" : 2},
                {"first" : 2},
                {"first" : 1},
                {"second" : "name 3"},]

print(sorted(dictionaries, key=lambda x: x.get("first")))

dictionaries = [

{"first" : 5},

{"first" : 3},

{"second" : 2},

{"first" : 2},

{"first" : 1},

{"second" : "name 3"},]

print(sorted(dictionaries, key=lambda x: x.get("first")))

Boom coś poszło nie tak 🙁


Traceback (most recent call last):
  File "dictionary_sorting.py", line 10, in 
    print(sorted(dictionaries, key=lambda x: x.get("first")))
TypeError: '<' not supported between instances of 'NoneType' and 'int'

Traceback (most recent call last):

File "dictionary_sorting.py", line 10, in

print(sorted(dictionaries, key=lambda x: x.get("first")))

TypeError: '<' not supported between instances of 'NoneType' and 'int'

No tak, próbujemy użyć operatora porównania dla typu None i int: None < int

Z pomocą przyjdzie nam mała magia. Wystarczy, że nasza lambda zwróci tuple z dwoma wartościami


lambda x: ("first" not in x, x.get("first"))

# {"first":1}   ->  (False, 1)
# {"second": 2) ->  (True, None)

lambda x: ("first" not in x, x.get("first"))

# {"first":1} -> (False, 1)

# {"second": 2) -> (True, None)

Pierwszy element to boolean a drugi wartość pod danym kluczem lub None w przypadku braku klucza.

Ponieważ False(0) jest przed True(1) dlatego użyte zostało „not in”


dictionaries = [
                {"first" : 5},
                {"first" : 3},
                {"second" : 2},
                {"first" : 2},
                {"first" : 1},
                {"second" : "name 3"},]

print(sorted(dictionaries, key=lambda x: ("first" not in x, x.get("first"))))

dictionaries = [

{"first" : 5},

{"first" : 3},

{"second" : 2},

{"first" : 2},

{"first" : 1},

{"second" : "name 3"},]

print(sorted(dictionaries, key=lambda x: ("first" not in x, x.get("first"))))

Zadanie wykonane. Słowniki są posortowane wg klucza który w innych słownikach nie istnieje.


[{'first': 1}, {'first': 2}, {'first': 3}, {'first': 5}, {'second': 2}, {'second': 'name 3'}]

[{'first': 1}, {'first': 2}, {'first': 3}, {'first': 5}, {'second': 2}, {'second': 'name 3'}]

Po usunięciu operatora NOT (w Pythonie True > False)


dictionaries = [
                {"first" : 5},
                {"first" : 3},
                {"second" : 2},
                {"first" : 2},
                {"first" : 1},
                {"second" : "name 3"},]

print(sorted(dictionaries, key=lambda x: ("first" in x, x.get("first"))))

dictionaries = [

{"first" : 5},

{"first" : 3},

{"second" : 2},

{"first" : 2},

{"first" : 1},

{"second" : "name 3"},]

print(sorted(dictionaries, key=lambda x: ("first" in x, x.get("first"))))

Otrzymamy


[{'second': 2}, {'second': 'name 3'}, {'first': 1}, {'first': 2}, {'first': 3}, {'first': 5}]

[{'second': 2}, {'second': 'name 3'}, {'first': 1}, {'first': 2}, {'first': 3}, {'first': 5}]