kubapok/2023-programowanie-w-pythonie
3
3
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity
8d76aaeb54
2023-programowanie-w-pythonie/zajecia1/.ipynb_checkpoints/2_podstawy-checkpoint.ipynb

2920 lines
56 KiB
Plaintext
Raw Normal View History

zajecia1
2023-11-18 10:21:48 +01:00
{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Podstawy języka Python\n",
"\n",
" \n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The area of the triangle is 14.696938456699069\n"
]
}
],
"source": [
"sides = [5, 6, 7]\n",
"\n",
"# calculate the semi-perimeter\n",
"s = sum(sides) / 2\n",
"\n",
"# calculate the area\n",
"area = s\n",
"for side in sides:\n",
" area = area * (s - side)\n",
"area = area ** 0.5\n",
"\n",
"print(f'The area of the triangle is {area}')"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Zmienne"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"user1 = \"Alicja\"\n",
"user2 = \"Bartosz\"\n",
"user3 = \"Cecylia\""
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"user = \"t.dwojak\"\n",
"mail_domain = \"amu.edu.pl\"\n",
"\n",
"email = user + '@' + mail_domain"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Zmienne\n",
" * Nazwy zmiennych muszą być unikatowe.\n",
" * Wielkość liter w nazwie zmiennych ma znaczenie.\n",
" * Brak konieczności określenia typu."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Funkcja `print`"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello Python!\n"
]
}
],
"source": [
"print('Hello Python!')"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello\n",
"Python\n",
"Hello Python !\n"
]
}
],
"source": [
"print('Hello') \n",
"print('Python')\n",
"print('Hello', 'Python', '!')"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"tomasz\n",
"Użytkownik: tomasz\n"
]
}
],
"source": [
"user = 'tomasz'\n",
"\n",
"print(user)\n",
"print('Użytkownik:', user)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Typy liczbowe\n",
"\n",
" * liczby całkowite: `int`\n",
" * liczby rzeczywiste (zmiennoprzecinkowe): `float`"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"year = 2021\n",
"pi = 3.14159"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Dziś jest 17 / 10 / 2021\n"
]
}
],
"source": [
"day = 17\n",
"month = 10\n",
"year = 2021\n",
"\n",
"print('Dziś jest', day, '/', month, '/', year)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Operacje arytmetyczne na liczbach:\n",
" * dodawanie `+`, np. `2 + 3`\n",
" * odejmowanie `-`, np. `10-9`\n",
" * mnożenie `*`, np. `2.0 * 3.0`\n",
" * dzielenie `/`, np. `3 / 4` ( == 0.75)\n",
" * dzielenie całkowite `//`, np. `3 / 4` (0)\n",
" * reszta z dzielenia `%`, np. `6 % 4` (2)\n",
" * potęgowanie `**`, np. `10 ** 3` (1000)\n",
" * nawiasy `(...)`"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Dziś upłynęło 36840 sekund.\n"
]
}
],
"source": [
"hour = 10\n",
"minutes = 14\n",
"seconds = ((60 * 60 * hour) + 60 * minutes)\n",
"print(\"Dziś upłynęło\", seconds, \"sekund.\")"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"11\n"
]
}
],
"source": [
"print( 1 + (20 // 3) + (4 * -5) % 6)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Operacje na zmiennej\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"x = 5\n",
"\n",
"x = x + 5\n",
"\n",
"x += 5"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Operatory\n",
"\n",
"Na przykład:\n",
" * `+=`\n",
" * `-=`\n",
" * `/=`\n",
" * `*=`"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Konwersja typów"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"-3\n",
"3.0\n",
"3\n"
]
}
],
"source": [
"pi_int = int(-3.14)\n",
"print(pi_int)\n",
"\n",
"trzy = float(3)\n",
"print(trzy)\n",
"print(3)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"6.28\n",
"7.0\n"
]
}
],
"source": [
"x = '3.14'\n",
"print(float(x) * 2)\n",
"\n",
"print(int('42') / 6)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Wartości logiczne\n",
"\n",
"W Pythonie są dwie wartości logiczne:\n",
" * prawda (`True`),\n",
" * fałsz (`False`).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n"
]
}
],
"source": [
"x = False\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"* Wszystkie liczby różne od 0 mają wartość logiczną `True`.\n",
"* Funkcja `bool` pozwala na konwersję do zmiennej logicznej.\n",
"* Do negacji służy słowo kluczowe `not`."
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Wartość logiczna sumy: True\n",
"Wartość logiczna zera to: False False\n",
"True\n"
]
}
],
"source": [
"suma = 1 + 2\n",
"\n",
"print('Wartość logiczna sumy:', bool(suma))\n",
"\n",
"print('Wartość logiczna zera to: ', bool(0), bool(0.0))\n",
"\n",
"print(not False)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Operatory porównania\n",
" * równość: `==`\n",
" * różne: `!=`\n",
" * większy: `>`\n",
" * większy lub równy: `>=`\n",
" * mniejszy: `<`\n",
" * mniejszy lub równy `<=`\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n",
"True\n",
"False\n"
]
}
],
"source": [
"user = 'bob'\n",
"\n",
"print(user == 'bob')\n",
"\n",
"print(3 < 7)\n",
"\n",
"print(0 != 0.0)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Do łączenia warunków logicznych służą dwa słowa kluczowe:\n",
" * `and`: koniunkcja,\n",
" * `or`: alternatywa."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n",
"False\n",
"True\n",
"False\n"
]
}
],
"source": [
"print(True and True)\n",
"print(True and False)\n",
"print(True or False)\n",
"print(False or False)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"W Pythonie istnieje jeszcze jeden typ wartości `None`, który oznacza brak wartości lub wartość pustą. "
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Wartość zmiennej: None\n",
"Wartość logiczna zmiennej: False\n",
"False\n"
]
}
],
"source": [
"user = None\n",
"\n",
"print('Wartość zmiennej:', user)\n",
"print('Wartość logiczna zmiennej:', bool(user))\n",
"print(user == False)\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Czas na pierwsze zadanie (1a i 1b)."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Komentarze\n",
" * Komentarze nie są interpretowane.\n",
" * Komentarze w Pythonie zaczynają się od znaku '#'\n",
" * Istnieją komentarze wielolinijkowe tagowane potrójnym \", czyli \"\"\" \"\"\"\n"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Bardzo ważna wiadomość\n",
"Mamy piękną jesień.\n"
]
}
],
"source": [
"print(\"Bardzo ważna wiadomość\") # A to jest komentarz\n",
"\"\"\"\n",
"Komentarz\n",
"wielo-\n",
"linijkowy\n",
"\"\"\"\n",
"# print(\"Nie chcę być wydrukowanym\")\n",
"print(\"Mamy piękną jesień.\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true,
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Ciągi znaków (łańcuchy znakowe lub stringi)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
" * Możemy zdefiniować je na 3 sposoby: `''`, `\"\"` lub `str`.\n",
" * Python preferuje pojedynczy cudzysłów.\n",
" * Domyślne kodowanie to UTF-8."
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"user0 = 'John'\n",
"user1 = \"Alice\"\n",
"\n",
"nun_users = str(2)"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"It's fine.\n"
]
}
],
"source": [
"sent = \"It's fine.\"\n",
"\n",
"sent = 'It\\'s fine.'\n",
"\n",
"print(sent)"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"rok: 2021\n",
"False\n",
"True\n"
]
}
],
"source": [
"var = str(2021)\n",
"\n",
"print('rok:', var)\n",
"print(var == 2021)\n",
"print(var == '2021')"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"# Pusty ciąg znaków\n",
"x = ''"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Operacje na stringach\n",
" * łączenie: `+`\n",
" * powtórzenie: `*`"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"t.dwojak@amu.edu.pl\n"
]
}
],
"source": [
"username = 't.dwojak'\n",
"domain = 'amu.edu.pl'\n",
"email = username + '@' + domain\n",
"print(email)"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"NOOOOOOOO!\n"
]
}
],
"source": [
"big_no = 'N' + 'O' * 8 + '!'\n",
"print(big_no)"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Dziś jest 2021/10/17\n"
]
}
],
"source": [
"date = str(2021) + '/' + str(10) + '/' + str(17)\n",
"print('Dziś jest', date)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Operacje na stringach, cd.\n",
" * długość łańcucha znakowego: `len`: np. `len('Ala') == 3`,\n",
" * zamiana na małe litery `lower` lub na wielkie: `upper`,\n",
" * zamiana liter: `replace`,\n",
" * usuwanie białych znaków: `strip`,\n",
" * sprawdzenie czy string rozpoczyna sie danych prefiksem: `startswith`."
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Słowo mickiewicz ma 10 liter.\n",
"python\n",
"mickiewicz\n",
"2021\n",
"True\n"
]
}
],
"source": [
"user = 'mickiewicz'\n",
"print('Słowo', user, 'ma', len(user), 'liter.')\n",
"\n",
"print('Python'.lower())\n",
"\n",
"print(user.replace('T', 'R'))\n",
"\n",
"print(' 2021 '.strip())\n",
"\n",
"print(user.startswith('mic'))"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Słowo tomasz ma 6 liter.\n",
"Słowo tomasz ma 6 liter.\n",
"3\n"
]
}
],
"source": [
"user = 'tomasz'\n",
"print('Słowo', user, 'ma', len(user), 'liter.')\n",
"\n",
"print(f'Słowo {user} ma {len(user)} liter.')\n",
"\n",
"\n",
"print(len(str(123)))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Czas na zadanie (1c)."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Listy (`list`)\n",
" * Typ danych, który pozwala przechowywać wiele wartości.\n",
" * Dostęp do poszczególnych elementów jest przez indeks elementu.\n",
" * Indeksowanie zaczyna się od 0.\n",
" * Funkcja `list` zamienia obiekt na listę."
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"x = [] # albo równoważnie\n",
"y = list()\n",
"oceny = [5, 4, 3, 5, 5]\n",
"misc = [3.14, \"pi\", [\"pi\"], 3]\n",
"\n",
"list_0_9 = list(range(10))\n"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Liczba elementów: 4\n"
]
}
],
"source": [
"numbers = [6, 7, 9, 11]\n",
"print('Liczba elementów:', len(numbers))"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"7\n"
]
}
],
"source": [
"numbers = [6, 7, 9, 11]\n",
"\n",
"print(numbers[1])"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Dodawanie i usuwanie elementów z listy\n",
"\n",
"Istnieją dwie metody:\n",
" * `append(x)`: dodaje x na koniec listy\n",
" * `extend(x)`: rozszerza listę o każdy element z x "
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['duck-duck-go', 'yahoo']\n"
]
}
],
"source": [
"engines = []\n",
"\n",
"engines.append('duck-duck-go')\n",
"engines.append(\"yahoo\")\n",
"print(engines)"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['duck-duck-go', 'yahoo', 'google', 'bing']\n"
]
}
],
"source": [
"engines = ['duck-duck-go', 'yahoo']\n",
"searches = [\"google\", 'bing']\n",
"engines.extend(searches)\n",
"print(engines)"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['duck-duck-go', 'yahoo', 'google', 'bing']\n",
"['duck-duck-go', 'yahoo']\n"
]
}
],
"source": [
"engines = ['duck-duck-go', 'yahoo']\n",
"searches = [\"google\", 'bing']\n",
"\n",
"print(engines + searches)\n",
"print(engines)"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1, 3, 2, 3, 1, 2, 4]\n",
"[1, 3, 3, 1, 2, 4]\n"
]
}
],
"source": [
"liczby = [1, 2, 3, 2, 3, 1, 2, 4]\n",
"liczby.pop(1) # Domyślnie usuwa ostatni element z listy\n",
"print(liczby)\n",
"liczby.remove(2)\n",
"print(liczby)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Inne przydatne metody:\n",
" * `sort()`: sortuje listę rosnąco\n",
" * `count(x)`: zlicza wystąpienia x w liście\n",
" * `index(x)`: zwraca indeks pierwszego wystąpienia x"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2\n",
"7\n",
"[1, 1, 2, 2, 2, 3, 3, 4]\n"
]
}
],
"source": [
"liczby = [1,2,3,2,3,1,2,4]\n",
"print(liczby.count(1))\n",
"print(liczby.index(4))\n",
"liczby.sort()\n",
"print(liczby)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Indeksowanie"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"pierwszy element: 1\n",
"ostatni element: 4\n",
"5 pierwszych: [1, 3, 2, 3, 1]\n",
"5 ostatnich [2, 3, 1, 2, 4]\n",
"od drugiego, do piątego [3, 2, 3, 1]\n",
"parzyste: [3, 3, 2]\n",
"od tyłu [4, 2, 1, 3, 2, 3, 1]\n"
]
}
],
"source": [
"oceny = [1, 3, 2, 3, 1, 2, 4]\n",
"print('pierwszy element:', oceny[0])\n",
"print('ostatni element:', oceny[-1])\n",
"print('5 pierwszych:', oceny[:5])\n",
"print('5 ostatnich', oceny[-5:])\n",
"print('od drugiego, do piątego', oceny[1:5])\n",
"print('parzyste:', oceny[1:6:2])\n",
"print('od tyłu', oceny[::-1])"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Funkcje wbudowane\n",
" * `len` - zwraca liczbę elementów listy.\n",
" * `min` - zwraca wartość najmniejszgo elementu.\n",
" * `max` - zwraca wartość największego elementu.\n",
" * `sum` - zwraca sumę elementów.\n",
" * `all` - zwraca `True`, gdy wszystkie elementy mają wartość `True`.\n",
" * `any` - Zwraca `True`, gdy przynajmniej jeden element ma wartość `True`."
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Liczba elementów: 6\n",
"Najmniejszy element: 0\n",
"Największy element: 32\n",
"Suma elementów: 74\n",
"False\n",
"True\n"
]
}
],
"source": [
"numbers = [4, 8, 12, 18, 0, 32]\n",
"\n",
"print('Liczba elementów:', len(numbers))\n",
"print('Najmniejszy element:', min(numbers))\n",
"print('Największy element:', max(numbers))\n",
"print('Suma elementów:', sum(numbers))\n",
"\n",
"print(all(numbers))\n",
"print(any(numbers))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Krotki (`tuple`)\n",
"Podobnym typem do listy jest krotka (`tuple`):\n",
" * definiuje się ją `()` lub `tuple()`,\n",
" * nie można zmieniać krotki: nie można dodawać ani usuwać elementów,\n",
" * nie można również zmieniać elementów*,\n",
" * Indeksowanie identyczne jak w listach."
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"text/plain": [
"7"
]
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"numbers = (4, 5, 7)\n",
"\n",
"numbers[2]"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"([0, 1], [1, 2], [3, 4, 5])\n"
]
}
],
"source": [
"users = ([0], [1, 2], [3, 4, 5])\n",
"\n",
"users[0].append(1)\n",
"\n",
"print(users)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Czas na zadanie (2a, 2b, 2c)."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Słowniki (`dict`)\n",
"Pewnego rodzaju uogólnieniem listy jest słownik (`dict`), który przechowuje dane jako `klucz`: `wartość`.\n",
" * Słowniki pozwala na dodawanie, usuwanie i zmianę elementów.\n",
" * Definiujemy jako `{}` lub `dict()`.\n",
" * Klucze słownika muszą być niezmienialne (haszowalne)."
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"store = {}\n",
"store = dict()\n",
"s_oceny = {\n",
" \"Justyna\": [5,5,5],\n",
" \"Bartek\": [3,4,5],\n",
" \"Ola\": [3,3,3]}\n",
"s_oceny = dict([(\"Justyna\", [5,5,5]), (\"Bartek\", [3,4,5]), (\"Ola\", [3,3,3])])\n"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'Justyna': [5, 5, 5], 'Bartek': [3, 4, 5], 'Ola': [3, 3, 3]}\n"
]
}
],
"source": [
"s_oceny = {\"Justyna\" : [5,5,5], \"Bartek\" : [3,4,5], \"Ola\": [3,3,3]}\n",
"\n",
"print(s_oceny)"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[3, 4, 5]\n"
]
}
],
"source": [
"s_oceny = {\"Justyna\" : [5,5,5], \"Bartek\" : [3,4,5], \"Ola\": [3,3,3]}\n",
"user = 'Bartek'\n",
"print(s_oceny[user])"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'Justyna': [5, 5, 5], 'Bartek': [3, 4, 5], 'Ola': [3, 3, 3], 'Jan': [4, 4, 5]}\n"
]
}
],
"source": [
"s_oceny = {\"Justyna\" : [5,5,5], \"Bartek\" : [3,4,5], \"Ola\": [3,3,3]}\n",
"\n",
"s_oceny['Jan'] = [4, 4, 5]\n",
"\n",
"print(s_oceny)"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'Justyna': [5, 5, 5], 'Bartek': [3, 4, 5], 'Ola': [3, 3, 3, 1, 4]}\n"
]
}
],
"source": [
"s_oceny = {\"Justyna\" : [5,5,5], \"Bartek\" : [3,4,5], \"Ola\": [3,3,3]}\n",
"\n",
"s_oceny['Ola'].extend([1,4])\n",
"\n",
"print(s_oceny)"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'Bartek': [3, 4, 5], 'Ola': [3, 3, 3]}\n"
]
}
],
"source": [
"s_oceny = {\"Justyna\" : [5,5,5], \"Bartek\" : [3,4,5], \"Ola\": [3,3,3]}\n",
"\n",
"del s_oceny[\"Justyna\"]\n",
"\n",
"print(s_oceny)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Operacje\n",
" * Funkcja `len` zwraca liczbę elementów w słowniku.\n",
" * Domyślnie operacje funkcji wykonywane są na kluczach.\n",
" * metoda `keys()` zwraca klucze słownika, `values()` -- wartości, a `items()` -- pary (klucz, wartość). "
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"dict_keys([1, 3, 5, 11])\n",
"dict_values([1, 2, 2, 3])\n",
"dict_items([(1, 1), (3, 2), (5, 2), (11, 3)])\n"
]
}
],
"source": [
"binary_ones = {1: 1, 3: 2, 5: 2, 11: 3}\n",
"max(binary_ones)\n",
"\n",
"print(binary_ones.keys())\n",
"print(binary_ones.values())\n",
"print(binary_ones.items())"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"4\n"
]
}
],
"source": [
"s_oceny = {\"Justyna\" : [5,5,5], \"Bartek\" : [3,4,5], \"Ola\": [3,4,3]}\n",
"\n",
"print(s_oceny[\"Ola\"][1])"
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"28\n"
]
}
],
"source": [
"users = {'ali99': {'name': 'Alice', 'age': 28}, 'bob90': {'name': 'Bob', 'age': 19}}\n",
"\n",
"print(users['ali99']['age'])"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Czas na zadanie (3)."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Instrukcja warunkowa (`if ... elif ... else`)\n",
" * Pozwala na wykonanie (wciętego) fragmentu kodu w zależności od czy podany warunek jest spełniony:\n",
" ```python\n",
" if <warunek>:\n",
" instrukcja 1\n",
" ...\n",
" ```\n",
" * `elif` pozwala na sprawdzenie kolejnego warunku.\n",
" * `else` zostanie wykonany, gdy żaden warunek nie został spełniony.\n",
" * Elementy `elif` i `else` nie są obowiązkowe.\n"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"score_theory = 40\n",
"score_practical = 45\n",
"\n",
"if score_theory + score_practical > 100:\n",
" print(\"Zdobyłeś wystarczającą liczbę punktów.\")\n",
" print('------')"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"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."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Blok `else` jest opcjonalny i jest wykonywany, gdy warunek zawarty w instrukcji `if` nie jest spełniony. \n",
"\n",
"Na poniższym przykładnie mamy własnie taki przypadek. Warunek w `if`ie: `score_theory + score_practical > 100` nie jest spełniony, stąd wykonają się instrukcje z bloku `else`."
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Nie zdobyłeś wystarczającej liczby punktów.\n"
]
}
],
"source": [
"\n",
"score_theory = 40\n",
"score_practical = 45\n",
"\n",
"if score_theory + score_practical > 100:\n",
" print(\"Zdobyłeś wystarczającą liczbę punktów.\")\n",
" print('------')\n",
"else:\n",
" print(\"Nie zdobyłeś wystarczającej liczby punktów.\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"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`."
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Będziesz mieć dodatkowy egzamin.\n"
]
}
],
"source": [
"score_theory = 40\n",
"score_practical = 45\n",
"\n",
"if score_theory + score_practical > 100:\n",
" print(\"Zdobyłeś wystarczającą liczbę punktów.\")\n",
" print('------')\n",
"elif score_theory + score_practical > 80:\n",
" print(\"Będziesz mieć dodatkowy egzamin.\")\n",
"else:\n",
" print(\"Nie zdobyłeś wystarczającej liczby punktów.\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"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`. "
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Zdobyłeś wystarczającą liczbę punktów.\n",
"Wolisz teorię od praktyki\n"
]
}
],
"source": [
"score_theory = 55\n",
"score_practical = 50\n",
"\n",
"if score_theory + score_practical > 100:\n",
" print(\"Zdobyłeś wystarczającą liczbę punktów.\")\n",
" if score_theory > score_practical:\n",
" print('Wolisz teorię od praktyki')"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Sprawdzenie obecności w kolekcji (`in`)\n",
" * Słowo kluczowe `in` sprawdza czy dany element znajduje sie w kolekcji (np. lista, słownik).\n",
" * Jego negacja to `not in`.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"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.\n",
"\n",
"W poniższym przykładzie sprawdzamy, czy liczba `67` jest zawarta w liście."
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"67 jest na liście.\n"
]
}
],
"source": [
"numbers = [67, 101, 303]\n",
"\n",
"if 67 in numbers:\n",
" print('67 jest na liście.')"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"W przypadku słowników (`dict`) sprawdzane jest czy istnieje w słowniku zadany klucz."
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Jabłko jest składnikiem.\n"
]
}
],
"source": [
"ingredients = {'apple': 4, 'lemon': 1, 'cherry': 14}\n",
"\n",
"if 'apple' in ingredients:\n",
" print('Jabłko jest składnikiem.')"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Możemy wykorzystać warunek `in` do sprawdzenie, czy dany tekst jest podciągiem w drugim."
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Yes!\n"
]
}
],
"source": [
"my_programming_lang = \"Python\"\n",
"\n",
"if \"Pyt\" in my_programming_lang:\n",
" print('Yes!')"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Żeby sprawdzić czy dany element __nie występuje__ możemy wykorzystać instrukcję `not in`."
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Omiń alejkę ze słodyczami.\n"
]
}
],
"source": [
"shopping_list = ['apples', 'bread', 'carrots']\n",
"\n",
"if 'cookies' not in shopping_list:\n",
" print('Omiń alejkę ze słodyczami.')"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Obiekty o wartości logicznej `False`\n",
" * `0`\n",
" * `0.0`\n",
" * `[]`\n",
" * `()`\n",
" * `{}`\n",
" * `None`"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Bardzo często można spotkać się, gdy chcemy sprawdzić np. czy data lista jest pusta."
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"numbers = []\n",
"\n",
"if numbers:\n",
" print('średnia liczb to:', sum(numbers) / len(numbers))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Czas na zadanie (4a, 4b)."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Pętla typu ```for```\n",
" * W Pythonie pętla *for* działa jak pętla *for each* w innych językach;\n",
" ```python\n",
" for zmienna in kolekcja:\n",
" instukcja 1\n",
" instrukcja 2\n",
" ...\n",
"```\n",
" * Pętla pozwala na zapętlenie kodu, który znajduje w wciętym bloku.\n",
" * 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.\n",
" * Funkcja `range(n)` zwraca kolekcję liczb od `0` do `n-1`."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"To na co warto zwrócić uwagę to wcięcie. Kod, który ma zostać wykonany w pętli musi być wcięty."
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"element apples\n",
"element cherries\n",
"element pineapple\n"
]
}
],
"source": [
"ingredients = ['apples', 'cherries', 'pineapple']\n",
"\n",
"for ingredient in ingredients:\n",
" print('element', ingredient)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Funkcja `range(n)` zwraca obiekt, który możemy przekonwertowąć na listę elementów od 0 do `n-1`."
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0, 1, 2, 3, 4]\n"
]
}
],
"source": [
"print(list(range(5)))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Bardzo często można spotkać poniżsżą kombinację funkcji `range` i `len` w kontekście pętli:"
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"apples\n",
"cherries\n",
"pineapple\n"
]
}
],
"source": [
"ingredients = ['apples', 'cherries', 'pineapple']\n",
"\n",
"for i in range(len(ingredients)):\n",
" print(ingredients[i])"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"W przypadku połączenia słownika i pętli, do zmiennej przypisywane są kolejne klucze ze słownika (przykład poniżej):"
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"apple\n",
"lemon\n",
"cherry\n"
]
}
],
"source": [
"shopping_list = {'apple': 4, 'lemon': 1, 'cherry': 14}\n",
"for item in shopping_list:\n",
" print(item)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"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:"
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Buy 4 apples\n",
"Buy 1 lemon\n",
"Buy 14 cherries\n"
]
}
],
"source": [
"shopping_list = {'apples': 4, 'lemon': 1, 'cherries': 14}\n",
"for item, number in shopping_list.items():\n",
" print('Buy', number, item)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Możemy też iterować po stringu -- znak po znaku:"
]
},
{
"cell_type": "code",
"execution_count": 64,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"P\n",
"y\n",
"t\n",
"h\n",
"o\n",
"n\n"
]
}
],
"source": [
"for char in 'Python':\n",
" print(char)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Ćwiczenie: czy rozumiesz kod, który był na początku zajęć?"
]
},
{
"cell_type": "code",
"execution_count": 65,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The area of the triangle is 14.696938456699069\n"
]
}
],
"source": [
"sides = [5, 6, 7]\n",
"\n",
"# calculate the semi-perimeter\n",
"s = sum(sides) / 2\n",
"\n",
"# calculate the area\n",
"area = s\n",
"for side in sides:\n",
" area = area * (s - side)\n",
"area = area ** 0.5\n",
"\n",
"print(f'The area of the triangle is {area}')"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Zagnieżdżając dwie pętle musimy pamiętać o dodatkowym wcięciu (tak jak w przykładzie poniżej)."
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"2\n",
"4\n",
"3\n",
"6\n",
"9\n"
]
}
],
"source": [
"for i in range(3):\n",
" for j in range(i+1):\n",
" print((i + 1) * (j + 1))\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Czas na zadanie (5a, 5b, 5c i 5d)."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Funkcje\n",
" * Pozwalają na uniknięcie pisania tego samego kodu za każdym razem.\n",
" * Pozwalają na wielokrotne wykorzystanie tego samego fragmentu kodu.\n",
" * Zwiększają czytelność kodu.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Definicja funkcji wygląda następująco:\n",
" * 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.\n",
" * następnie wcięty blok to będzie kod funkcji."
]
},
{
"cell_type": "code",
"execution_count": 67,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello!\n"
]
}
],
"source": [
"def hello():\n",
" print('Hello!')\n",
"\n",
"hello()"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"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."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Słowo kluczowe `return` pozwala na zwrócenie wartości przez funkcję. Poniższa funkcja `get_five` zwraca liczbę pięć."
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"5\n"
]
}
],
"source": [
"def get_five():\n",
" return 5\n",
"x = get_five()\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Argumenty funkcji umieszczamy w nawiasach:"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"```python\n",
"def nazwa_funkcji(arg_1, arg_2, arg_3):\n",
" instrukcja 1\n",
" instrukcja 2\n",
" return jakaś wartość\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Przykład: poniższa funkcja `get_bigger` przyjmuje dwa argumenty: `a` i `b`, które rozdzielamy przecinkiem."
]
},
{
"cell_type": "code",
"execution_count": 69,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"512\n"
]
}
],
"source": [
"def get_bigger(a, b):\n",
" if a >= b:\n",
" return a\n",
" return b\n",
"print(get_bigger(56, 512))"
]
},
{
"cell_type": "code",
"execution_count": 70,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"8.0\n"
]
}
],
"source": [
"def srednia(lista):\n",
" s = 0\n",
" for item in lista:\n",
" s += item\n",
" return s / len(lista) \n",
"\n",
"print(srednia([7,8,9]))"
]
},
{
"cell_type": "code",
"execution_count": 71,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"def count(lista, item):\n",
" l = 0\n",
" for i in lista:\n",
" if i == item:\n",
" l += 1\n",
" return l"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Podczas wywoływania funkcji możemy dopowiedzieć, która argument jaką przyjmuje wartość."
]
},
{
"cell_type": "code",
"execution_count": 72,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"text/plain": [
"3"
]
},
"execution_count": 72,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"count([5,5,5,4], 5)\n",
"count(lista=[5,5,5,4], item=5)\n",
"count(item=5, lista=[5,5,5,4])"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Czas na zadanie (7a i 7b)."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Korzystanie z bibliotek"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Python posiada bogatą kolekcję bibliotek wbudowanych, tzn. które są dostarczone wraz z interpreterem.\n",
"\n",
"Żeby móc wykorzystać daną bibliotekę, to musimy ją zaimportować. Możemy to zrobić na dwa sposoby:\n",
" * `import <nazwa_biblioteki>`. Dostęp do elementów jest poprzez `<nazwa_biblioteki>.nazwa_funkcji`.\n",
" * `from <nazwa_biblioteki> import <nazwa funkcji>`: pozwala na dołączenie elementów biblioteki, tak jakby były częścią naszego skryptu.\n",
" \n",
"Przykłady:"
]
},
{
"cell_type": "code",
"execution_count": 73,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"posix\n",
"Nazwa uzytkownika: kuba\n"
]
}
],
"source": [
"import os\n",
"print(os.name)\n",
"\n",
"from os import getenv\n",
"print('Nazwa uzytkownika: {}'.format(getenv(\"USER\")))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"1. Importujemy bibliotekę `os`. Dostęp do stałej jest \"przez kropkę\".\n",
"2. Z biblioreki `os` importujemy funkcję `getenv` (zwraca wartości zmiennych systemowych)."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Wystarczy, że zaimportujemy raz daną bibliotekę:"
]
},
{
"cell_type": "code",
"execution_count": 74,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"text/plain": [
"-1.0"
]
},
"execution_count": 74,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import math\n",
"math.cos(math.pi)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Jeżeli nazwa biblioteki jest za długa, to możemy użyć aliasu: `import <nazwa_biblioteki> as <alias>`:"
]
},
{
"cell_type": "code",
"execution_count": 75,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" October 2021\n",
"Mo Tu We Th Fr Sa Su\n",
" 1 2 3\n",
" 4 5 6 7 8 9 10\n",
"11 12 13 14 15 16 17\n",
"18 19 20 21 22 23 24\n",
"25 26 27 28 29 30 31\n"
]
}
],
"source": [
"import calendar as cal\n",
"cal.TextCalendar().prmonth(2021, 10)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Ważniejsze biblioteki wbudowane:\n",
" * `os`, `sys`: obsługa rzeczy dt. systemu i środowiska\n",
" * `datetime`: wszystko co jest związane z czasem\n",
" * `collections`: zawiera `Counter` i `defaultdict`"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Czas na zadanie (9a i 9b)."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Obsługa plików"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": 76,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Beautiful is better than ugly.\n",
"Explicit is better than implicit.\n",
"Simple is better than complex.\n"
]
}
],
"source": [
"zen_file = open('./zen_of_python.txt')\n",
"zen_text = zen_file.read()\n",
"print(zen_text[:95])\n",
"\n",
"zen_file.close()"
]
},
{
"cell_type": "code",
"execution_count": 77,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Beautiful is better than ugly.\n",
"Explicit is better than implicit.\n",
"Simple is better than complex.\n"
]
}
],
"source": [
"zen_file = open('./zen_of_python.txt')\n",
"\n",
"zen_lines = list(zen_file)\n",
"\n",
"for line in zen_lines[:3]:\n",
" print(line.strip())\n",
"\n",
"\n",
"zen_file.close()"
]
},
{
"cell_type": "code",
"execution_count": 78,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Beautiful is better than ugly.\n",
"Explicit is better than implicit.\n",
"Simple is better than complex.\n"
]
}
],
"source": [
"with open('./zen_of_python.txt') as zen_file:\n",
" print(zen_file.read()[:95])"
]
},
{
"cell_type": "code",
"execution_count": 79,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"tree_per_sqkm = {\n",
" \"Brazil\": 39542,\n",
" \"Bulgaria\": 24987,\n",
"}\n",
"\n",
"with open('./zalesienie.txt', mode='w') as plik:\n",
" for country, num_trees in tree_per_sqkm.items():\n",
" plik.write(country + ',' + str(num_trees) + '\\n')\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Podstawy Obiektowości\n",
"\n",
" - W Pythonie każda wartość jest obiektem, tzn. może zostać przypisana do zmiennej lub zostać\n",
"przekazane do funkcji.\n",
" - Każda wartość może mieć metody lub atrybuty."
]
},
{
"cell_type": "code",
"execution_count": 80,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"11\n",
"5\n"
]
}
],
"source": [
"from datetime import date\n",
"\n",
"today = date(2022, 11, 5)\n",
"\n",
"print(today.month) # atrybut\n",
"print(today.weekday()) # metoda"
]
}
],
"metadata": {
"celltoolbar": "Slideshow",
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.3"
}
},
"nbformat": 4,
"nbformat_minor": 1
}
Reference in New Issue Copy Permalink