Wizualizacja danych
- Wykład 3

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

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 są uporządkowane
  • 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]

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]

Bibliografia

Bibliografia - cd2

Bibliografia - cd3