Wprowadzenie
do języka Python
- Wykład 2

Instrukcje warunkowe

Składnia

if <expr>:
    <statement>

else

if <expr>:
    <statement(s)>
else:
    <statement(s)>
a = 5
if a > 0:
    print("Liczba dodatnia")
else:
    print("Liczna ujemna lub zero")
Liczba dodatnia

x = 0
y = 5
if x < y:
    print('yes1')

if y < x:
    print('yes2')

if x:
    print('yes3')

if y:
    print('yes4')

if x or y:
    print('yes5')

if x and y:
    print('yes6')
yes1
yes4
yes5

elif

if <expr>:
    <statement(s)>
elif <expr>:
    <statement(s)>
elif <expr>:
    <statement(s)>
    ...
else:
    <statement(s)>
a = 5
if a > 0:
    print("Liczba dodatnia")
elif a == 0:
    print("Zero")
else:
    print("Liczna ujemna")
Liczba dodatnia

Zagnieżdżone instrukcje warunkowe:

if <expr>:
    <statement(s)>
    if <expr>:
        <statement(s)>
i = 21
if i > 0:
    print("liczba jest dodatnia")
    if i % 2 == 0:
        print("Liczba jest dodatkowo parzysta")
liczba jest dodatnia

for - pętla

for i in <collection>:
    <loop body>

Przykład:

for i in range(5):
    print(i)
0
1
2
3
4

range

Generuje nam ciąg liczb (dedykowany typ range). Trzeba zamienić na listę “by podejrzeć”.

Uwaga: wszystkie argumenty muszą być w typie całkowitym.

Jeden argument - to “koniec” - ciąg tworzą liczby naturalne od \(0\) do \(n-1\). Krok domyślny to 1.

Dwa argumenty - to “początek” i “koniec”. Krok domyślny to 1. Wtedy wyświetlone są liczby całkowite z przedziału lewostronnie domkniętego \([początek, koniec)\).

Trzy argumenty - to “początek”, “koniec” oraz krok.

print(list(range(5)))
print(list(range(1, 11)))
print(list(range(0, 30, 5)))
print(list(range(0, 10, 3)))
print(list(range(0, -10, -1)))
print(list(range(0)))
print(list(range(1, 0)))
[0, 1, 2, 3, 4]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[0, 5, 10, 15, 20, 25]
[0, 3, 6, 9]
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
[]
[]

While - pętla

while <expr>:
    <statement(s)>

Przykład:

i = 0
while i < 5:
    print(i)
    i = i + 1
0
1
2
3
4

Zagnieżdżone pętle

for i in <collection>:
    <loop body>
    for i in <collection>:
        <loop body>

inna opcja:

while <expr>:
    <statement(s)>
    while <expr>:
        <statement(s)>
for i in range(3):
    for j in range(3):
        print(i, "*", j, "=", i * j)
0 * 0 = 0
0 * 1 = 0
0 * 2 = 0
1 * 0 = 0
1 * 1 = 1
1 * 2 = 2
2 * 0 = 0
2 * 1 = 2
2 * 2 = 4

break/continue

break

n = 5
while n > 0:
    n -= 1
    if n == 2:
        break
    print(n)
4
3

continue

n = 5
while n > 0:
    n -= 1
    if n == 2:
        continue
    print(n)
4
3
1
0

Typowanie a pętle

Na ten moment nie jest obowiązkowe https://peps.python.org/pep-0526/#id11

i: int
for i in range(5):
    print(i)
0
1
2
3
4

Kolejność operatorów

Od ostatniego:

  • lambda
  • if - else
  • or
  • and
  • not x
  • in, not in, is, is not, <, <=, >, >=, !=, ==
  • |
  • ^
  • &
  • <<, >>
  • +, -

  • *, @, /, //, %
  • +x, -x, ~x
  • **
  • await x
  • x[index], x[index:index], x(arguments...), x.attribute
  • (expressions...), [expressions...], {key: value...},{expressions...}

Źródło: https://docs.python.org/3/reference/expressions.html#operator-precedence.

Pytanie do przemyślenia

Co oznacza w Pythonie, że wartości przekazywane są przez referencję?

a = 5
b = a
b += 2
print(a)
print(b)
5
7

Listy

Lista w Pythonie to tzw. typ sekwencyjny umożliwia przechowywanie elementów różnych typów.

Cechy:

  • zmienny (mutable) - umożliwia przypisanie wartości pojedynczym elementom
  • do zapisu używamy nawiasów kwadratowych
  • poszczególne elementy rozdzielamy przecinkami
  • każdy element listy ma przyporządkowany indeks
  • elementy listy są numerowane od zera
  • listy dopuszcają porządek (o ile elementy są porównywalne)
  • listy są dynamiczne (mogą mieć różną długość)
  • listy mogą być zagnieżdżone

Uwaga!

Listy w języku Python są specyficzną strukturą danych nie zawsze dostępną w innych językach programowania. Pojęcie listy w całej informatyce “szersze”. Wyróżnia się np. listy jednokierunkowe, które nie muszą mieć indeksu. Nie będziemy takich przypadków analizować.

nazwa = [element1, element2, ..., elementN]

Pusta lista:

a = []
b = list()

Lista z liczbami:

a = [2, 3, 4.5, 5, -3.2]

Lista mieszana:

b = ['abcd', 25+3j, True, 1]

Listy a typowanie

https://mypy.readthedocs.io/en/stable/cheat_sheet_py3.html

Wersja “stara” do Pythona 3.8:

from typing import List

x: List[int] = [1]

Wersja “nowa” do Pythona 3.9 (brak modułu) i 3.10 (operator |):

x: list[int | str] = [3, 5, "test", "fun"]

Słowo kluczowe Optional

from typing import Optional

x: Optional[int] = 5
print(x)
x = None
print(x)
x = 7
print(x)
a: list[Optional[int]] = [5, None]
print(x)
5
None
7
7

Słowo kluczowe Any

from typing import Any

x: Any = 5
print(x)
x = None
print(x)
x = "abc"
print(x)
a: list[Any] = [5, None, "abc"]
print(x)
5
None
abc
abc

Kolejność ma znaczenie

a = [1, 2, 3, 4]
b = [4, 3, 2, 1]
print(a == b)
False

Elementy na liście nie muszą być unikalne

a = [1, 2, 3, 4, 2]
b = [1, 2, 3, 4]
print(a)
print(a == b)
[1, 2, 3, 4, 2]
False

Indeks - dostęp do elementów listy (od zera)

a = [1, 3, 'abc', False, -2.3, 'XYZ', 9.3]
print(a[1])
print(a[4])
print(a[0])
#print(a[7])
3
-2.3
1
a = [1, 3, 'abc', False, -2.3, 'XYZ', 9.3]
print(a[-1])
print(a[-5])
print(a[-7])
9.3
abc
1
a = [1, 3, 'abc', False, -2.3, 'XYZ', 9.3]
print(a[1:4])
print(a[-5:-2])
print(a[:4])
[3, 'abc', False]
['abc', False, -2.3]
[1, 3, 'abc', False]
a = [1, 3, 'abc', False, -2.3, 'XYZ', 9.3]
print(a[2:])
print(a[0:6:2])
print(a[1:6:2])
['abc', False, -2.3, 'XYZ', 9.3]
[1, 'abc', -2.3]
[3, False, 'XYZ']
a = [1, 3, 'abc', False, -2.3, 'XYZ', 9.3]
print(a[6:0:-2])
print(a[::-1])
print(a[:])
[9.3, -2.3, 'abc']
[9.3, 'XYZ', -2.3, False, 'abc', 3, 1]
[1, 3, 'abc', False, -2.3, 'XYZ', 9.3]
a = [1, 3, 'abc', False, -2.3, 'XYZ', 9.3]
print(a[::2])
print(a[::-2])
[1, 'abc', -2.3, 9.3]
[9.3, -2.3, 'abc', 1]

Specjalne funkcje

Długość (rozmiar listy)

a = [1, 3, 'abc', False, -2.3, 'XYZ', 9.3]
print(len(a))
7

Implementacja samodzielna długości:

def dlugosc(lista):
    x = 0
    for i in lista:
        x += 1

    return x


a = [1, 3, 'abc', False, -2.3, 'XYZ', 9.3]
print(dlugosc(a))
7

Maksimum i minimum?

Działa wtedy gdy mamy porządek

  • liczby <=
  • napisy - porządek leksykograficzny (omówimy przy napisach)
a = [4,-5,3.4,-11.2]
print(min(a))
print(max(a))
b = ['abc', 'ABCd', 'krt', 'abcd']
print(min(b))
print(max(b))
-11.2
4
ABCd
krt

Modyfikacja i wstawianie

a = [4,-5,3.4,-11.2]
a[2] = 'a'
print(a)
[4, -5, 'a', -11.2]
a = [4,-5,3.4,-11.2]
a[2] = ['a','b']
print(a)
[4, -5, ['a', 'b'], -11.2]
a = [4,-5,3.4,-11.2]
a[1:2] = ['a','b']
print(a)
[4, 'a', 'b', 3.4, -11.2]
a = [4,-5,3.4,-11.2]
a[1:3] = ['a','b']
print(a)
[4, 'a', 'b', -11.2]

Dodawanie list

a = [4,-5,3.4,-11.2]
b = ['a','b','c']
print(a+b)
[4, -5, 3.4, -11.2, 'a', 'b', 'c']

Mnożenie listy przez liczbę całkowitą (int)

a = [4,-5,3.4,-11.2]
print(a*2)
print(2*a)
[4, -5, 3.4, -11.2, 4, -5, 3.4, -11.2]
[4, -5, 3.4, -11.2, 4, -5, 3.4, -11.2]

Usuwanie elementów z listy

a = [1, 3, 'abc', False, -2.3, 'XYZ', 9.3]
del a[2]
print(a)
del a[:]
print(a)
[1, 3, False, -2.3, 'XYZ', 9.3]
[]

Do poczytania

list.append(x) - dodaje element na końcu listy. Równoważnie a[len(a):] = [x]

a = [1, 3, 'abc', False]
a.append(5.3)
print(a)
[1, 3, 'abc', False, 5.3]

list.extend(iterable) - dodaje elementy z argumenty na koniec listy. Równoważnie: a[len(a):] = iterable

a = [1, 3, 'abc', False]
b = [3, -2]
a.extend(b)
print(a)
[1, 3, 'abc', False, 3, -2]

Różnice?

a = [1, 3, 'abc', False]
b = [3, -2]
a.append(b)
print(a)
[1, 3, 'abc', False, [3, -2]]

list.insert(i, x) - wstawia element x na pozycji i

a = [1, 3, 'abc', False]
a.insert(0,'w')
print(a)
a.insert(4,9.0)
print(a)
['w', 1, 3, 'abc', False]
['w', 1, 3, 'abc', 9.0, False]

list.remove(x) - usuwa element z listy (pierwszy od początku)

a = [1, 3, 'abc', False]
a.remove(False)
print(a)
b = [3, 4, 5, 3]
b.remove(3)
print(b)
[1, 3, 'abc']
[4, 5, 3]

list.pop() - usuwa i zwraca ostatni element

list.pop(i) - usuwa i zwraca element na pozycji i

a = [1, 3, 'abc', False]
print(a.pop())
print(a)
b = [3, -4, 6.2, 7]
print(b.pop(3))
print(b)
False
[1, 3, 'abc']
7
[3, -4, 6.2]

list.clear() - usuwa wszystkie elementy z listy. Równoważnie: del a[:]

a = [1, 3, 'abc', False]
a.clear()
print(a)
[]

list.index(x) - zwraca indeks elementu x (o ile istnieje, inaczej błąd), w przypadku duplikatów pierwszy z lewej list.index(x,start) - zwraca indeks elementu x (o ile istnieje, inaczej błąd) zaczynając od pozycji start, w przypadku duplikatów pierwszy z lewej list.index(x,start,end) - zwraca indeks elementu x (o ile istnieje, inaczej błąd) zaczynając od pozycji start a kończąc na end-1, w przypadku duplikatów pierwszy z lewej

a = [1, 3, 1, 4, 5, 2, 3]
print(a.index(3))
print(a.index(3, 5))
print(a.index(3, 1, 4))
1
6
1
a = ['abc','xyz','abc','efg']
print(a.index('abc'))
print(a.index('abc', 2))
print(a.index('abc', 1, 4))
0
2
2

list.count(x) - zwraca ile razy występuję element x na liście

a = ['abc','xyz','abc','efg']
print(a.count('abc'))
print(a.count(4))
2
0

list.sort() - sortuje listę (o ile elementy można posortować)

a = ['abc','xyz','abc','efg']
a.sort()
print(a)
['abc', 'abc', 'efg', 'xyz']

list.reverse() - odwraca kolejność elementów na liście (nie ma nic związku z sortowaniem!)

a = [4, 5, -2, 7.3, 9, -22, 23]
a.reverse()
print(a)
[23, -22, 9, 7.3, -2, 5, 4]

list.copy() - tworzy kopię listy

Spójrzmy na przykład jak działa operator przypisania dla list.

a = [4, 5, -2, 7.3, 9, -22, 23]
b = a
b[2] = 100
print(b)
print(a)
[4, 5, 100, 7.3, 9, -22, 23]
[4, 5, 100, 7.3, 9, -22, 23]

Różnica z użyciem copy.

a = [4, 5, -2, 7.3, 9, -22, 23]
b = a.copy()
b[2] = 100
print(b)
print(a)
[4, 5, 100, 7.3, 9, -22, 23]
[4, 5, -2, 7.3, 9, -22, 23]

Lista jako stos

stack = [3, 4, 5, 8, 9]
stack.append(6)
stack.append(7)
print(stack)
print(stack.pop())
print(stack)
[3, 4, 5, 8, 9, 6, 7]
7
[3, 4, 5, 8, 9, 6]

Lista jako kolejka

from collections import deque

queue = deque(["aw", "tg", "kj"])
queue.append("gg")
print(queue)
print(queue.popleft())
print(queue)
deque(['aw', 'tg', 'kj', 'gg'])
aw
deque(['tg', 'kj', 'gg'])

List Comprehensions

squares = []
for x in range(5):
    squares.append(x ** 2)

print(squares)
[0, 1, 4, 9, 16]
squares = [x**2 for x in range(5)]
print(squares)
[0, 1, 4, 9, 16]

Krotka - tuple

krotka = 123, 'abc', True
krotka2 = (123, 'abc', True)
print(krotka[2])
True
krotka[0] = 1
## TypeError: 'tuple' object does not support item assignment

https://docs.python.org/3.10/library/stdtypes.html#tuple

Zbiór - set

cyfry = {'raz', 'dwa', 'raz', 'trzy', 'raz', 'osiem'}
print(cyfry)
{'trzy', 'raz', 'dwa', 'osiem'}

https://docs.python.org/3.10/library/stdtypes.html#set

Słownik

tel = {'jack': 4098, 'sape': 4139}
tel['guido'] = 4127
print(tel)
tel['jack']
del tel['sape']
tel['irv'] = 4127
print(tel)
{'jack': 4098, 'sape': 4139, 'guido': 4127}
{'jack': 4098, 'guido': 4127, 'irv': 4127}

https://docs.python.org/3.10/library/stdtypes.html#mapping-types-dict

Python comprehension

a = [3, 4, 5]
print(a)
a2 = [i**2 for i in a]
print(a2)
a3 = {i**2 for i in a}
print(a3)
a4 = {i: i**2 for i in a}
print(a4)
[3, 4, 5]
[9, 16, 25]
{16, 9, 25}
{3: 9, 4: 16, 5: 25}
a = [3, 4, 5]
print(a)
a2 = (i**2 for i in a)
print(a2)
for i in a2:
    print(i)
[3, 4, 5]

<generator object <genexpr> at 0x000001FF141E7E60>
9
16
25
a = [3, 4, "w", 5]
print(a)
w = [i*i for i in a if isinstance(i, int)]
print(w)
[3, 4, 'w', 5]
[9, 16, 25]
a = [3, 4, "w", 5]
print(a)
w = [i*i if isinstance(i, int) else i for i in a]
print(w)
[3, 4, 'w', 5]
[9, 16, 'w', 25]

Bibliografia