Kategoria: Python

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.

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