Notatki / różne warianty / dodatki

Zadanie 1. Wynik różnych działań na liczbach

>>> 0 ** 0
1
>>> 0 ** 2
0

2. zwracanie uwagi czy jest przecinek czy kropka

>>> 0.3 % 2
0.3

3. typ: tuple, wynik: (0, 1), bo najpierw 0 % 2, a następnie 3 % 2

>>> 0,3 % 2 
(0,1)

4. typ: tuple, wynik: (0, 3, 2), wynikiem jest sumowanie obydwu list

>>> 0,3 + 0,2
(0, 3, 2)

>>> 4 << 1
8
>>> 2 << 1
4

typ : int , wynik: 4, operator bitowy << traktuje podane liczby jako ciągi bitowe. Ostatecznie zwraca wynik typu int, przekonwertowany z zapisu binarnego. Przemnożenie 2 przez 2 ** 1.

Operatory bitowe:

• bin(zmienna) - zamienia na notację bitową
• Wyrażenie x << y zwraca x z bitami przesuniętymi w lewo o y miejsc (nowe bity po prawej stronie to zera). Jest to to samo, co pomnożenie x przez 2 ** y.
• Wyrażenie x >> y zwraca x z bitami przesuniętymi w prawo o y miejsc. Jest to to samo, co dzielenie x przez 2 ** y.
• Wyrażenie x & y to wykonywanie operatora logicznego and na bitach. Każdy bit wyjścia wynosi 1, jeśli odpowiadający bit z x oraz z y wynosi 1, w przeciwnym razie bit wyjścia będzie wynosił 0.
• Wyrażenie x | yto wykonywanie operatora logicznego or na bitach.
• Wyrażenie ~x zwraca dopełnienie liczby x - liczbę otrzymaną przez przełączenie każdego z bitów 1 na 0 i każde 0 na 1. Jest to to samo co -x - 1.
• Wyrażenie x ^ y zwraca bit wyjścia, taki sam, jak odpowiadający mu bit w liczbie x, ale tylko w przypadku jeśli ten bit w ciągu bitów y jest równy 0. Jeśli ten bit w y jest równy 1 to bit wyjściowy będzie dopełnieniem bitu znajdującego się w x.

6. operatory logiczne działanie logiczne 'and' wykonało się dla konkretnej wartości wewnątrz krotki, '2' jest przepisane, a wykonało się '3 and 4'

>>> 2,3 and 4
(2,4)
>>> 2 and 3
3 # gdy wartość większa od 1 zwraca ostatnią wartość która wystąpi

7. modulo

>>> 7 % 0
wyjątek, nie można dzielić przez zero
>>> 5.5 % 3.0
2.5

8. potęgowanie

>>> -1 ** 2  # nie bierze pod uwage minusa, potęguje samą liczbę
-1
>>> (-1) ** 2
1

9. dzielenie

>>> -2,5 // 2 # dzielenie z zaokrągleniem w dół(podłoga), wykonujemy działanie tylko przy jednej 
              # wartości w krotce
(-2,2)
>> int (7/2) # obcinanie końcówki - trunc
3
>> -5, 5 // 2, 0
(-5, 2, 0)

>>> (1,2) * 2
(1,2,1,2)  # przemnożenie całej krotki 2 razy

Zadanie 2. Wynik działań na stringach

>>> a = 'kocham'
>>> b = 'programowac'
>>> c = 'znam'
>>> d = 'pythona'

1. upper, lower

>>> a.upper()
'KOCHAM'

2. dopuszczalne 'działania matematyczne' na napisach : dodawanie dwóch napisów, mnożenie napisów przez jakąś liczbę

>>> a - b
Exception
>>> a + b
'kochamprogramowac'
>>> a * 2
'kochamkocham'

3. funkcja find

>>> a.find('x')
-1
>>> c.find('a')
2

4. napis w napisie

>>> a[4:6]
'am'
>>> a[4:6] in b
True
>>> c[3] in d
False

>>> a[::-1]
'mahcok'
>>> c[:-1]
'zna'

>>> '%s %s' / (a,b)
Exception
>>> '%s %s' % (a,b)
'kocham programowac'

Zadanie 3. Działania na listach

1. sort

>>> a = [5, 4, 1]
>>> a.sort()
[1, 4, 5]

>>> a = [5, 6.0, 1]
>>> a.sort()
[1, 5, 6.0]

2. : :

>>> a = [1, 2, 3, ]
>>> a = [:a[0]]
>>> a
[1]   # wszystkie elementy z listy od początku do elementu zerowego 

>>> a = [2, 3]
>>> a[-2:] = [3] #zastąp wszystkie elementy od pozycji -2 trójką
>>> a
[3]

>>> a = [1, 2, 3, 4, 5]
>>> a[0:2] = [3]
>>> a
[3, 3, 4, 5]

>>> a = [1, 2, 3, 4, 5]
>>> a[0:1] = [6, 7, 8]
>>> a
[6, 7, 8, 2, 3, 4, 5]

>>> a = [1,2]
>>> a[-1:] = [3]  # od -1 do 0 zmienia na [3]
>>> a
[3, 2]

3. extend

>>> a = list('kot')
>>> a.extend('ara')
>>> a
['k', 'o', 't, 'a', 'r', 'a']

Zadanie 4. List comprehension

1. wszystkie liczby z listy a, które nie występują w liście b

>>> [x for x in a if x not in b]

2. wszystkie pary liczb (x,y) takie, że x należy do a , y należy do b i x jest podzielne przez y

>>> [(x,y) for x in a for y in b if x % y == 0]

3. temperaturę wyrażoną w stopniach Farenheita, przeliczoną ze stopni Celsjusza (wszystkie liczby z a i b)

>>> [32 + (9/5) * x for x in a + b] 
# a + b - łączenie list, w list comprehension nie może być extend

Zadanie 5. Wartości zmiennych

and zwraca ostatni element, jeśli wszystkie są prawdziwe, lub pierwszy nieprawdziwy. or zwraca pierwszy element, który będzie prawdziwy, lub ostatni, gdy wszystkie nieprawdziwe.

>>> a = 1 and [1, 2, 3]
>>> b = 1 or a
>>> a
[1, 2, 3]
>>> b
1

>>> b = 1 and a
>>> b
[1, 2, 3]

2. dowiązania

>>> a = {1:[2,3]}
>>> b = a.copy()  # dowiązanie, tworzy identyczny element
>>> del b[1][0]
>>> a     # jeśli jest dowiązanie, elementy są ze sobą połączone i 
	  # zmiany w jednym to też zmiany w drugim
{1:[3]}
>>> b
{1:[3]}

3. dodawanie elementów w stringach, krotkach

>>> a = b = '1'
>>> a += a
>>> a
'11'
>>> b
'1'

>>> a = b = (1,)
>>> a += a
>>> a
(1, 1)
>>> b
(1, )

4. działania matematyczne na listach

>>> a = b = (1)
>>> b* = [2, 3]
>>> a
1
>>> b
[2,3]

Zadanie 6. Klasy, pętle, generatory

>>> g = (x for x in (1, 2))              # generator
>>> for a in (x for x in (1, 2, 3)):     # ta pętla wywoła się trzy razy
...   for b in g:                        # ta pętla wywoła się dwa razy wypisze 1,2
...     print(b) 
...
1
2

>>> class C:
...   x = 2
...   y = 3
...
>>> class D(object):
...   x = 4
...   y = 5
...
>>> c = C()
>>> d = c
>>> c.x = 8
>>> d.y = 7
>>> C.x = 1
>>> print(c.x, d.x, C.x, D.x, c.y, d.y, C.y, D.y)
8, 8, 1, 4, 7, 7, 3, 5

Zadanie 7. Typy modyfikowalne i niemodyfikowalne

modyfikowalne: list, dict, int, float, bool, set niemodyfikowalne: string, tuple

Zadanie 8. Funkcje

>>> def a(y):
...   y *= 1
...   print(y)
...
>>> x = 2
>>> a(x)
2

>>> y = 2
>>> def a(x == y):
...   x += 1
...   print(x)
...
>>> a(y)
Exception

>>> def a(x, i = 2):
...   x.append(i)
...   print(x)
...
>>> a([2], 1)
[2, 1]
>>> a([1])
[1, 2]

>>> x = 1
>>> def b():
...   x = 2
...   def a(): print(x)
...   x = 3
...   return a
...
>>> a = b()
>>> a()           # wywołanie funkcji wewnętrznej a, przyjmie za x = 3 
		  # ponieważ x = 3 jest po x = 2 w deklaracji funkcji zewnętrznej
3

>>> def a(x=y):
...   x += 1
...   print(x)
>>> y = 2
>>> a(y)
3

Zadanie 9. Różne rodzaje przyjmowanych argumentów

>>> def f(x, y = 1, *z, **w): print(w, x, y, z)   # funkcja przyjmuje za argumenty: 
						  # x, y z wartością domyślną 1, krotkę i słownik
>>> f(1)
{} 1 1 ()
>>> f(1, 2, y = 3)
Exception : multiple values for argument 'y'      # dwie wartości podane dla argumentu y - 2 i 3
>>> f(*{1}, **{'z':4})
{'z':4} 1 1 ()
>>> f(1, 2, 3, 4)
{} 1 2 (3, 4)

>>> def f(w, x = 1, *y, **z): print(w, x, y, z)
>>> f(1)
1 1 () {}
>>> f(1, 2, y=3)
1 2 () {'y': 3}
>>> f(*{1}, **{'z': 4})
1 1 () {'z': 4}
>>> f(1, 2, 3, 4)
1 2 (3, 4) {}

Zadanie 10. Generatory, iteratory

1. Generator dodatnich liczb nieparzystych mniejszych od n

>>> def f(n):
...   x = 1
...   while x < n:
...     yield x
...     x += 2

2. Generator dodatnich liczb parzystych mniejszych od n (czemu rozwiązanie jest złe ????)

>>> def f(n):
...   x = 1
...   while x < n:
...     if x % 2 == 0:
...       yield x
...       x += 1

Zadanie 11. Klasy

class Zwierze:
  def __init__(self, imie, gatunek):
      self.imie = imie
      self.gatunek = gatunek
	def __repr__(self):
      return '%s %s' % (self.gatunek, self.imie)
      
class Ssak(Zwierze):
  pass
  
class Ptak(Zwierze):
  def lataj():
    pass
    
class Zoo:
	def __init__(self):
		self.zwierzeta = []

	def dodaj_zwierze(self, zwierze):
		self.zwierzeta.append(zwierze)
	
	def __repr__(self):
    return str(self.zwierzeta)

wywołanie:

>> jozek = Ssak('Józek', 'kot')
>> antek = Ptak('Antek', 'wróbel')
>> jozek
'kot Józek'
>> antek
'wróbel Antek'
>> zoo = Zoo()
>> zoo.dodaj_zwierze(antek)
>> zoo.dodaj_zwierze(jozek)
>> zoo
[wróbel Antek, kot Józek]