2023-programowanie-w-pythonie/zajecia1/.ipynb_checkpoints/2_podstawy-checkpoint.ipynb

Podstawy języka Python

 

sides = [5, 6, 7]

# calculate the semi-perimeter
s = sum(sides) / 2

# calculate the area
area = s
for side in sides:
    area = area * (s - side)
area = area ** 0.5

print(f'The area of the triangle is {area}')

The area of the triangle is 14.696938456699069

Zmienne

user1 = "Alicja"
user2 = "Bartosz"
user3 = "Cecylia"

user = "t.dwojak"
mail_domain = "amu.edu.pl"

email = user + '@' + mail_domain

Zmienne

• Nazwy zmiennych muszą być unikatowe.
• Wielkość liter w nazwie zmiennych ma znaczenie.
• Brak konieczności określenia typu.

Funkcja print

print('Hello Python!')

Hello Python!

print('Hello') 
print('Python')
print('Hello', 'Python', '!')

Hello
Python
Hello Python !

user = 'tomasz'

print(user)
print('Użytkownik:', user)

tomasz
Użytkownik: tomasz

Typy liczbowe

• liczby całkowite: int
• liczby rzeczywiste (zmiennoprzecinkowe): float

year = 2021
pi = 3.14159

day = 17
month = 10
year = 2021

print('Dziś jest', day, '/', month, '/', year)

Dziś jest 17 / 10 / 2021

Operacje arytmetyczne na liczbach:

• dodawanie +, np. 2 + 3
• odejmowanie -, np. 10-9
• mnożenie *, np. 2.0 * 3.0
• dzielenie /, np. 3 / 4 ( == 0.75)
• dzielenie całkowite //, np. 3 / 4 (0)
• reszta z dzielenia %, np. 6 % 4 (2)
• potęgowanie **, np. 10 ** 3 (1000)
• nawiasy (...)

hour = 10
minutes = 14
seconds = ((60 * 60 * hour) +  60 * minutes)
print("Dziś upłynęło", seconds, "sekund.")

Dziś upłynęło 36840 sekund.

print( 1 + (20 // 3) + (4 * -5) % 6)

11

Operacje na zmiennej

x = 5

x = x + 5

x += 5

Operatory

Na przykład:

• +=
• -=
• /=
• *=

Konwersja typów

pi_int = int(-3.14)
print(pi_int)

trzy = float(3)
print(trzy)
print(3)

-3
3.0
3

x = '3.14'
print(float(x) * 2)

print(int('42') / 6)

6.28
7.0

Wartości logiczne

W Pythonie są dwie wartości logiczne:

• prawda (True),
• fałsz (False).

x = False
print(x)

False

• Wszystkie liczby różne od 0 mają wartość logiczną True.
• Funkcja bool pozwala na konwersję do zmiennej logicznej.
• Do negacji służy słowo kluczowe not.

suma = 1 + 2

print('Wartość logiczna sumy:', bool(suma))

print('Wartość logiczna zera to: ', bool(0), bool(0.0))

print(not False)

Wartość logiczna sumy: True
Wartość logiczna zera to:  False False
True

Operatory porównania

• równość: ==
• różne: !=
• większy: >
• większy lub równy: >=
• mniejszy: <
• mniejszy lub równy <=

user = 'bob'

print(user == 'bob')

print(3 < 7)

print(0 != 0.0)

True
True
False

Do łączenia warunków logicznych służą dwa słowa kluczowe:

• and: koniunkcja,
• or: alternatywa.

print(True and True)
print(True and False)
print(True or False)
print(False or False)

True
False
True
False

W Pythonie istnieje jeszcze jeden typ wartości None, który oznacza brak wartości lub wartość pustą.

user = None

print('Wartość zmiennej:', user)
print('Wartość logiczna zmiennej:', bool(user))
print(user == False)

Wartość zmiennej: None
Wartość logiczna zmiennej: False
False

Czas na pierwsze zadanie (1a i 1b).

Komentarze

• Komentarze nie są interpretowane.
• Komentarze w Pythonie zaczynają się od znaku '#'
• Istnieją komentarze wielolinijkowe tagowane potrójnym ", czyli """ """

print("Bardzo ważna wiadomość") # A to jest komentarz
"""
Komentarz
wielo-
linijkowy
"""
# print("Nie chcę być wydrukowanym")
print("Mamy piękną jesień.")

Bardzo ważna wiadomość
Mamy piękną jesień.

Ciągi znaków (łańcuchy znakowe lub stringi)

• Możemy zdefiniować je na 3 sposoby: '', "" lub str.
• Python preferuje pojedynczy cudzysłów.
• Domyślne kodowanie to UTF-8.

user0 = 'John'
user1 = "Alice"

nun_users = str(2)

sent = "It's fine."

sent = 'It\'s fine.'

print(sent)

It's fine.

var = str(2021)

print('rok:', var)
print(var == 2021)
print(var == '2021')

rok: 2021
False
True

# Pusty ciąg znaków
x = ''

Operacje na stringach

• łączenie: +
• powtórzenie: *

username = 't.dwojak'
domain = 'amu.edu.pl'
email = username + '@' + domain
print(email)

t.dwojak@amu.edu.pl

big_no = 'N' + 'O' * 8 + '!'
print(big_no)

NOOOOOOOO!

date = str(2021) + '/' + str(10) + '/' + str(17)
print('Dziś jest', date)

Dziś jest 2021/10/17

Operacje na stringach, cd.

• długość łańcucha znakowego: len: np. len('Ala') == 3,
• zamiana na małe litery lower lub na wielkie: upper,
• zamiana liter: replace,
• usuwanie białych znaków: strip,
• sprawdzenie czy string rozpoczyna sie danych prefiksem: startswith.

user = 'mickiewicz'
print('Słowo', user, 'ma', len(user), 'liter.')

print('Python'.lower())

print(user.replace('T', 'R'))

print('      2021     '.strip())

print(user.startswith('mic'))

Słowo mickiewicz ma 10 liter.
python
mickiewicz
2021
True

user = 'tomasz'
print('Słowo', user, 'ma', len(user), 'liter.')

print(f'Słowo {user} ma {len(user)} liter.')


print(len(str(123)))

Słowo tomasz ma 6 liter.
Słowo tomasz ma 6 liter.
3

Czas na zadanie (1c).

Listy (list)

• Typ danych, który pozwala przechowywać wiele wartości.
• Dostęp do poszczególnych elementów jest przez indeks elementu.
• Indeksowanie zaczyna się od 0.
• Funkcja list zamienia obiekt na listę.

x = [] # albo równoważnie
y = list()
oceny = [5, 4, 3, 5, 5]
misc = [3.14, "pi", ["pi"], 3]

list_0_9 = list(range(10))

numbers = [6, 7, 9, 11]
print('Liczba elementów:', len(numbers))

Liczba elementów: 4

numbers = [6, 7, 9, 11]

print(numbers[1])

7

Dodawanie i usuwanie elementów z listy

Istnieją dwie metody:

• append(x): dodaje x na koniec listy
• extend(x): rozszerza listę o każdy element z x

engines = []

engines.append('duck-duck-go')
engines.append("yahoo")
print(engines)

['duck-duck-go', 'yahoo']

engines = ['duck-duck-go', 'yahoo']
searches = ["google", 'bing']
engines.extend(searches)
print(engines)

['duck-duck-go', 'yahoo', 'google', 'bing']

engines = ['duck-duck-go', 'yahoo']
searches = ["google", 'bing']

print(engines + searches)
print(engines)

['duck-duck-go', 'yahoo', 'google', 'bing']
['duck-duck-go', 'yahoo']

liczby = [1, 2, 3, 2, 3, 1, 2, 4]
liczby.pop(1) # Domyślnie usuwa ostatni element z listy
print(liczby)
liczby.remove(2)
print(liczby)

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

Inne przydatne metody:

• sort(): sortuje listę rosnąco
• count(x): zlicza wystąpienia x w liście
• index(x): zwraca indeks pierwszego wystąpienia x

liczby = [1,2,3,2,3,1,2,4]
print(liczby.count(1))
print(liczby.index(4))
liczby.sort()
print(liczby)

2
7
[1, 1, 2, 2, 2, 3, 3, 4]

Indeksowanie

oceny = [1, 3, 2, 3, 1, 2, 4]
print('pierwszy element:', oceny[0])
print('ostatni element:', oceny[-1])
print('5 pierwszych:', oceny[:5])
print('5 ostatnich', oceny[-5:])
print('od drugiego, do piątego', oceny[1:5])
print('parzyste:', oceny[1:6:2])
print('od tyłu', oceny[::-1])

pierwszy element: 1
ostatni element: 4
5 pierwszych: [1, 3, 2, 3, 1]
5 ostatnich [2, 3, 1, 2, 4]
od drugiego, do piątego [3, 2, 3, 1]
parzyste: [3, 3, 2]
od tyłu [4, 2, 1, 3, 2, 3, 1]

Funkcje wbudowane

• len - zwraca liczbę elementów listy.
• min - zwraca wartość najmniejszgo elementu.
• max - zwraca wartość największego elementu.
• sum - zwraca sumę elementów.
• all - zwraca True, gdy wszystkie elementy mają wartość True.
• any - Zwraca True, gdy przynajmniej jeden element ma wartość True.

numbers = [4, 8, 12, 18, 0,  32]

print('Liczba elementów:', len(numbers))
print('Najmniejszy element:', min(numbers))
print('Największy element:', max(numbers))
print('Suma elementów:', sum(numbers))

print(all(numbers))
print(any(numbers))

Liczba elementów: 6
Najmniejszy element: 0
Największy element: 32
Suma elementów: 74
False
True

Krotki (tuple)

Podobnym typem do listy jest krotka (tuple):

• definiuje się ją () lub tuple(),
• nie można zmieniać krotki: nie można dodawać ani usuwać elementów,
• nie można również zmieniać elementów*,
• Indeksowanie identyczne jak w listach.

numbers = (4, 5, 7)

numbers[2]

7

users = ([0], [1, 2], [3, 4, 5])

users[0].append(1)

print(users)

([0, 1], [1, 2], [3, 4, 5])

Czas na zadanie (2a, 2b, 2c).

Słowniki (dict)

Pewnego rodzaju uogólnieniem listy jest słownik (dict), który przechowuje dane jako klucz: wartość.

• Słowniki pozwala na dodawanie, usuwanie i zmianę elementów.
• Definiujemy jako {} lub dict().
• Klucze słownika muszą być niezmienialne (haszowalne).

store = {}
store = dict()
s_oceny = {
    "Justyna": [5,5,5],
    "Bartek": [3,4,5],
    "Ola": [3,3,3]}
s_oceny = dict([("Justyna", [5,5,5]), ("Bartek", [3,4,5]), ("Ola", [3,3,3])])

s_oceny = {"Justyna" : [5,5,5], "Bartek" : [3,4,5], "Ola": [3,3,3]}

print(s_oceny)

{'Justyna': [5, 5, 5], 'Bartek': [3, 4, 5], 'Ola': [3, 3, 3]}

s_oceny = {"Justyna" : [5,5,5], "Bartek" : [3,4,5], "Ola": [3,3,3]}
user = 'Bartek'
print(s_oceny[user])

[3, 4, 5]

s_oceny = {"Justyna" : [5,5,5], "Bartek" : [3,4,5], "Ola": [3,3,3]}

s_oceny['Jan'] = [4, 4, 5]

print(s_oceny)

{'Justyna': [5, 5, 5], 'Bartek': [3, 4, 5], 'Ola': [3, 3, 3], 'Jan': [4, 4, 5]}

s_oceny = {"Justyna" : [5,5,5], "Bartek" : [3,4,5], "Ola": [3,3,3]}

s_oceny['Ola'].extend([1,4])

print(s_oceny)

{'Justyna': [5, 5, 5], 'Bartek': [3, 4, 5], 'Ola': [3, 3, 3, 1, 4]}

s_oceny = {"Justyna" : [5,5,5], "Bartek" : [3,4,5], "Ola": [3,3,3]}

del s_oceny["Justyna"]

print(s_oceny)

{'Bartek': [3, 4, 5], 'Ola': [3, 3, 3]}

Operacje

• Funkcja len zwraca liczbę elementów w słowniku.
• Domyślnie operacje funkcji wykonywane są na kluczach.
• metoda keys() zwraca klucze słownika, values() -- wartości, a items() -- pary (klucz, wartość).

binary_ones = {1: 1, 3: 2, 5: 2, 11: 3}
max(binary_ones)

print(binary_ones.keys())
print(binary_ones.values())
print(binary_ones.items())

dict_keys([1, 3, 5, 11])
dict_values([1, 2, 2, 3])
dict_items([(1, 1), (3, 2), (5, 2), (11, 3)])

s_oceny = {"Justyna" : [5,5,5], "Bartek" : [3,4,5], "Ola": [3,4,3]}

print(s_oceny["Ola"][1])

4

users = {'ali99': {'name': 'Alice', 'age': 28}, 'bob90': {'name': 'Bob', 'age': 19}}

print(users['ali99']['age'])

28

Czas na zadanie (3).

Instrukcja warunkowa (if ... elif ... else)

• Pozwala na wykonanie (wciętego) fragmentu kodu w zależności od czy podany warunek jest spełniony:

  if <warunek>:
   instrukcja 1
   ...
  

• elif pozwala na sprawdzenie kolejnego warunku.
• else zostanie wykonany, gdy żaden warunek nie został spełniony.
• Elementy elif i else nie są obowiązkowe.

score_theory = 40
score_practical = 45

if score_theory + score_practical > 100:
    print("Zdobyłeś wystarczającą liczbę punktów.")
    print('------')

Jedną ważną rzeczą jest to, że kod, który następuje po instrukcji if jest wcięty. Dzięki temu interpreter Pythona jest w stanie określić, które instrucje wchodzą w skład bloku warunkowego, a które nie.

Blok else jest opcjonalny i jest wykonywany, gdy warunek zawarty w instrukcji if nie jest spełniony.

Na poniższym przykładnie mamy własnie taki przypadek. Warunek w ifie: score_theory + score_practical > 100 nie jest spełniony, stąd wykonają się instrukcje z bloku else.

score_theory = 40
score_practical = 45

if score_theory + score_practical > 100:
    print("Zdobyłeś wystarczającą liczbę punktów.")
    print('------')
else:
    print("Nie zdobyłeś wystarczającej liczby punktów.")

Nie zdobyłeś wystarczającej liczby punktów.

Instrukcja warunkowa if pozwala na sprawdzenie wielu warunków -- służy do tego instrukcja elif (else if). Warunki są sprawdzane po kolei (od góry): jeżeli warunek zawarty po if nie jest spełniony, wtedy sprawdzany jest pierszy warunek z elif. Gdy żaden warunek nie jest spełniony, wtedy wykona się kod zawarty w bloku else.

score_theory = 40
score_practical = 45

if score_theory + score_practical > 100:
    print("Zdobyłeś wystarczającą liczbę punktów.")
    print('------')
elif score_theory + score_practical > 80:
    print("Będziesz mieć dodatkowy egzamin.")
else:
    print("Nie zdobyłeś wystarczającej liczby punktów.")

Będziesz mieć dodatkowy egzamin.

Nic nie stoi na przeszkodzie, żeby zagnieżdżać instrukcje warunkowe. W poniższym przykładzie widzimy, że druga instrukcja warunkowa jest zawarta w bloku po pierwszym if.

score_theory = 55
score_practical = 50

if score_theory + score_practical > 100:
    print("Zdobyłeś wystarczającą liczbę punktów.")
    if score_theory > score_practical:
        print('Wolisz teorię od praktyki')

Zdobyłeś wystarczającą liczbę punktów.
Wolisz teorię od praktyki

Sprawdzenie obecności w kolekcji (in)

• Słowo kluczowe in sprawdza czy dany element znajduje sie w kolekcji (np. lista, słownik).
• Jego negacja to not in.

Python zawiera bardzo przydatny warunek in, który sprawdza czy dany element jest zawarty w danej kolecji, np. w liście lub w słowniku.

W poniższym przykładzie sprawdzamy, czy liczba 67 jest zawarta w liście.

numbers = [67, 101, 303]

if 67 in numbers:
    print('67 jest na liście.')

67 jest na liście.

W przypadku słowników (dict) sprawdzane jest czy istnieje w słowniku zadany klucz.

ingredients = {'apple': 4, 'lemon': 1, 'cherry': 14}

if 'apple' in ingredients:
    print('Jabłko jest składnikiem.')

Jabłko jest składnikiem.

Możemy wykorzystać warunek in do sprawdzenie, czy dany tekst jest podciągiem w drugim.

my_programming_lang = "Python"

if "Pyt" in my_programming_lang:
    print('Yes!')

Yes!

Żeby sprawdzić czy dany element nie występuje możemy wykorzystać instrukcję not in.

shopping_list = ['apples', 'bread', 'carrots']

if 'cookies' not in shopping_list:
    print('Omiń alejkę ze słodyczami.')

Omiń alejkę ze słodyczami.

Obiekty o wartości logicznej False

• 0
• 0.0
• []
• ()
• {}
• None

Bardzo często można spotkać się, gdy chcemy sprawdzić np. czy data lista jest pusta.

numbers = []

if numbers:
    print('średnia liczb to:', sum(numbers) / len(numbers))

Czas na zadanie (4a, 4b).

Pętla typu for

• W Pythonie pętla _for działa jak pętla for each w innych językach;

  for zmienna in kolekcja:
    instukcja 1
    instrukcja 2
    ...
  

• Pętla pozwala na zapętlenie kodu, który znajduje w wciętym bloku.
• Konstrukcja pętli jest następująca: po słowie for musimy podać nazwę zmiennej, która po kolei będzie przyjmować wartości z kolekcji, np. z listy. Pętla wykona się tyle razy, ile jest elementów w kolekcji.
• Funkcja range(n) zwraca kolekcję liczb od 0 do n-1.

To na co warto zwrócić uwagę to wcięcie. Kod, który ma zostać wykonany w pętli musi być wcięty.

ingredients = ['apples', 'cherries', 'pineapple']

for ingredient in ingredients:
    print('element', ingredient)

element apples
element cherries
element pineapple

Funkcja range(n) zwraca obiekt, który możemy przekonwertowąć na listę elementów od 0 do n-1.

print(list(range(5)))

[0, 1, 2, 3, 4]

Bardzo często można spotkać poniżsżą kombinację funkcji range i len w kontekście pętli:

ingredients = ['apples', 'cherries', 'pineapple']

for i in range(len(ingredients)):
    print(ingredients[i])

apples
cherries
pineapple

W przypadku połączenia słownika i pętli, do zmiennej przypisywane są kolejne klucze ze słownika (przykład poniżej):

shopping_list = {'apple': 4, 'lemon': 1, 'cherry': 14}
for item in shopping_list:
    print(item)

apple
lemon
cherry

Jak wcześniej wspomniałem, metoda items() zwraca listę krotek: (klucz, wartość) i możemy wykorzystać to w pętli for. W tym przypadku musimy podać dwie zmienne:

shopping_list = {'apples': 4, 'lemon': 1, 'cherries': 14}
for item, number in shopping_list.items():
    print('Buy', number, item)

Buy 4 apples
Buy 1 lemon
Buy 14 cherries

Możemy też iterować po stringu -- znak po znaku:

for char in 'Python':
    print(char)

P
y
t
h
o
n

Ćwiczenie: czy rozumiesz kod, który był na początku zajęć?

sides = [5, 6, 7]

# calculate the semi-perimeter
s = sum(sides) / 2

# calculate the area
area = s
for side in sides:
    area = area * (s - side)
area = area ** 0.5

print(f'The area of the triangle is {area}')

The area of the triangle is 14.696938456699069

Zagnieżdżając dwie pętle musimy pamiętać o dodatkowym wcięciu (tak jak w przykładzie poniżej).

for i in range(3):
    for j in range(i+1):
        print((i + 1) * (j + 1))

1
2
4
3
6
9

Czas na zadanie (5a, 5b, 5c i 5d).

Funkcje

• Pozwalają na uniknięcie pisania tego samego kodu za każdym razem.
• Pozwalają na wielokrotne wykorzystanie tego samego fragmentu kodu.
• Zwiększają czytelność kodu.

Definicja funkcji wygląda następująco:

• najpierw piszemy słowo kłuczowe def, następnie nazwę funkcji, później w nawiasach okrągłych listę argumentów i kończymy dwukropkiem.
• następnie wcięty blok to będzie kod funkcji.

def hello():
    print('Hello!')

hello()

Hello!

W powyższym przykładzie zdefiniowaliśmy funkcje hello, która nie przyjmuje żadnych argumentów. Wywołanie tej funkcji nie różni się od wywołań innych funkcji.

Słowo kluczowe return pozwala na zwrócenie wartości przez funkcję. Poniższa funkcja get_five zwraca liczbę pięć.

def get_five():
    return 5
x = get_five()
print(x)

5

Argumenty funkcji umieszczamy w nawiasach:

def nazwa_funkcji(arg_1, arg_2, arg_3):
    instrukcja 1
    instrukcja 2
    return jakaś wartość

Przykład: poniższa funkcja get_bigger przyjmuje dwa argumenty: a i b, które rozdzielamy przecinkiem.

def get_bigger(a, b):
    if a >= b:
        return a
    return b
print(get_bigger(56, 512))

512

def srednia(lista):
    s = 0
    for item in lista:
        s += item
    return s / len(lista) 

print(srednia([7,8,9]))

8.0

def count(lista, item):
    l = 0
    for i in lista:
        if i == item:
            l += 1
    return l

Podczas wywoływania funkcji możemy dopowiedzieć, która argument jaką przyjmuje wartość.

count([5,5,5,4], 5)
count(lista=[5,5,5,4], item=5)
count(item=5, lista=[5,5,5,4])

3

Czas na zadanie (7a i 7b).

Korzystanie z bibliotek

Python posiada bogatą kolekcję bibliotek wbudowanych, tzn. które są dostarczone wraz z interpreterem.

Żeby móc wykorzystać daną bibliotekę, to musimy ją zaimportować. Możemy to zrobić na dwa sposoby:

• import <nazwa_biblioteki>. Dostęp do elementów jest poprzez <nazwa_biblioteki>.nazwa_funkcji.

• from <nazwa_biblioteki> import <nazwa funkcji>: pozwala na dołączenie elementów biblioteki, tak jakby były częścią naszego skryptu.

  Przykłady:

import os
print(os.name)

from os import getenv
print('Nazwa uzytkownika: {}'.format(getenv("USER")))

posix
Nazwa uzytkownika: kuba

1. Importujemy bibliotekę os. Dostęp do stałej jest "przez kropkę".
2. Z biblioreki os importujemy funkcję getenv (zwraca wartości zmiennych systemowych).

Wystarczy, że zaimportujemy raz daną bibliotekę:

import math
math.cos(math.pi)

-1.0

Jeżeli nazwa biblioteki jest za długa, to możemy użyć aliasu: import <nazwa_biblioteki> as <alias>:

import calendar as cal
cal.TextCalendar().prmonth(2021, 10)

    October 2021
Mo Tu We Th Fr Sa Su
             1  2  3
 4  5  6  7  8  9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31

Ważniejsze biblioteki wbudowane:

• os, sys: obsługa rzeczy dt. systemu i środowiska
• datetime: wszystko co jest związane z czasem
• collections: zawiera Counter i defaultdict

Czas na zadanie (9a i 9b).

Obsługa plików

zen_file = open('./zen_of_python.txt')
zen_text = zen_file.read()
print(zen_text[:95])

zen_file.close()

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.

zen_file = open('./zen_of_python.txt')

zen_lines = list(zen_file)

for line in zen_lines[:3]:
    print(line.strip())


zen_file.close()

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.

with open('./zen_of_python.txt') as zen_file:
    print(zen_file.read()[:95])

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.

tree_per_sqkm = {
    "Brazil": 39542,
    "Bulgaria": 24987,
}

with open('./zalesienie.txt', mode='w') as plik:
    for country, num_trees in tree_per_sqkm.items():
        plik.write(country + ',' + str(num_trees) + '\n')

Podstawy Obiektowości

• W Pythonie każda wartość jest obiektem, tzn. może zostać przypisana do zmiennej lub zostać przekazane do funkcji.
• Każda wartość może mieć metody lub atrybuty.

from datetime import date

today = date(2022, 11, 5)

print(today.month) # atrybut
print(today.weekday()) # metoda

11
5