From 8d76aaeb54b4e64c070fa29cceed3165109d4f2b Mon Sep 17 00:00:00 2001 From: Jakub Pokrywka Date: Sun, 19 Nov 2023 12:10:37 +0100 Subject: [PATCH] add odpowiedzi --- zajecia1/odpowiedzi.ipynb | 655 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 655 insertions(+) create mode 100644 zajecia1/odpowiedzi.ipynb diff --git a/zajecia1/odpowiedzi.ipynb b/zajecia1/odpowiedzi.ipynb new file mode 100644 index 0000000..5c7a920 --- /dev/null +++ b/zajecia1/odpowiedzi.ipynb @@ -0,0 +1,655 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "Sprawdź czy tekst 'aAaAaA' znajduje się w tablicy passwords.\n", + "W zależności czy znajduje się czy też nie, wyświetl na ekranie odpowiedni komunikat.\n", + "\"\"\"\n", + "\n", + "passwords = ['aaAaa', 'aAAAaa', 'aaaaaaA', 'aaaAAAAA', 'aaAAAaa', 'aAaAaA', 'aAaAaAA']" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "napisaAaAaAznajduje sie w tablicy passwords\n" + ] + } + ], + "source": [ + "if 'aAaAaA' in passwords:\n", + " print('napis ' + 'aAaAaA' + ' znajduje sie w tablicy passwords')\n", + "else:\n", + " print(' napis' + 'aAaAaA' + ' nie znajduje sie w tablicy passwords')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "Niech x oznacza liczbę uzyskanych punktów. Standardowa skala ocen jest następująca:\n", + "* x >= 90 -- 5.0\n", + "* 90 > x >= 80 -- 4.5\n", + "* 80 > x >= 70 -- 4.0\n", + "* 70 > x >= 60 -- 3.5\n", + "* 60 > x >= 50 -- 3.0\n", + "* x < 50 -- 2.0\n", + "\n", + "Zmienna `points` zawiera liczbę uzyskanych punktów przez studenta.\n", + "Napisz instrukcję warunką, która wyświetli ocenę studenta w zależności od liczby punktów.\n", + "\"\"\"\n", + "\n", + "points = 85\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Twoja ocena to: 4.5\n", + "Twoja ocena to: 4.5\n" + ] + } + ], + "source": [ + "def print_grade(grade):\n", + " print('Twoja ocena to: ',grade)\n", + " \n", + " \n", + "# te rozwiązanie korzysta z ciekawej możliwości zawarcia dwóch warunków a= 90:\n", + " print_grade(5.0)\n", + "elif 90 > points >= 80:\n", + " print_grade(4.5)\n", + "elif 80 > points >= 70:\n", + " print_grade(4.0)\n", + "elif 70 > points >= 60:\n", + " print_grade(3.5)\n", + "elif 60 > points >= 50:\n", + " print_grade(3.0)\n", + "else:\n", + " print_grade(2.0)\n", + " \n", + "# albo można tak:\n", + "if points >= 90:\n", + " print_grade(5.0)\n", + "elif 90 > points:\n", + " print_grade(4.5)\n", + "elif 80 > points:\n", + " print_grade(4.0)\n", + "elif 70 > points:\n", + " print_grade(3.5)\n", + "elif 60 > points:\n", + " print_grade(3.0)\n", + "else:\n", + " print_grade(2.0)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "230181" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "Oblicz sumę liczb od 1 do 678.\n", + "\"\"\"\n", + "# te dodanie 1 jest ważne, bo python nie włącza końca przedziału\n", + "sum(list(range(1,678+1)))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\"\"\"\n", + "Słownik `oceny` zawiera oceny kilku osób. Kluczami są imiona dzieci, a wartosciami -- ich oceny.\n", + "Uzupełnij słownik `rozklad`, którego kluczami są oceny, a wartosciami -- listy... \n", + "\"\"\"\n", + "\n", + "oceny = {\n", + " 'Albert': 4.5,\n", + " 'Beata': 5,\n", + " 'Cecylia': 4,\n", + " 'Dariusz': 4,\n", + " 'Eliza': 3,\n", + " 'Feliks': 5,\n", + " 'Grzegorz': 4.5,\n", + " 'Izabela': 4.5\n", + "}\n", + "\n", + "rozklad = {\n", + " 5: [],\n", + " 4.5: [],\n", + " 4: [],\n", + " 3: []\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{5: ['Beata', 'Feliks'],\n", + " 4.5: ['Albert', 'Grzegorz', 'Izabela'],\n", + " 4: ['Cecylia', 'Dariusz'],\n", + " 3: ['Eliza']}" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "for key, value in oceny.items():\n", + " rozklad[value].append(key)\n", + "rozklad\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\"\"\"\n", + "Poniżej znajdują się 2 słowniki z danymi o liczbie przejazdów rowerami miejskimi w Montrealu w 2018 z podziałem na miesiące (od kwietnia do listopada).\n", + "Pierwszy słownik zawiera informacje o przejazdach wykonanych przez posiadaczy abonamentu, a drugi przez ludzi, którzy\n", + "nie mają wykupionego abonamentu. Dane pochodzą ze strony https://montreal.bixi.com/en/open-data. \n", + "\n", + "a) Stwórz trzeci słownik `all_rides`, w którym zliczysz łączną liczbę przejazdów w każdym z podanych miesięcy.\n", + "b) Oblicz sumę zarejestrowanych przejazdów od kwietnia do listopada.\n", + "c) Wyswietl jaki procent wszystkich przejazdów odbyło się w sierpniu (August).\n", + "\n", + "\"\"\"\n", + "\n", + "members = {\n", + " 'April': 211819,\n", + " 'May': 682758,\n", + " 'June': 737011,\n", + " 'July': 779511,\n", + " 'August': 673790,\n", + " 'September': 673790,\n", + " 'October': 444177,\n", + " 'November': 136791,\n", + "}\n", + "\n", + "occasionals = {\n", + " 'April': 32058,\n", + " 'May': 147898,\n", + " 'June': 171494,\n", + " 'July': 194316,\n", + " 'August': 206809,\n", + " 'September': 140492,\n", + " 'October': 53596,\n", + " 'November': 10516,\n", + "}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'April': 243877, 'May': 830656, 'June': 908505, 'July': 973827, 'August': 880599, 'September': 814282, 'October': 497773, 'November': 147307}\n", + "5296826\n", + "16.62503166990949 %\n", + "16.63 %\n" + ] + } + ], + "source": [ + "all_rides = dict()\n", + "for key,value in members.items():\n", + " all_rides[key] = value\n", + "\n", + "for key,value in occasionals.items():\n", + " all_rides[key] += value\n", + "\n", + "print(all_rides)\n", + "# można też to zrobić szybciej korzystająć z list comprehensions, albo np biblioteki copy\n", + "\n", + "print(sum(all_rides.values()))\n", + "\n", + "print(100 * all_rides['August'] / sum(all_rides.values()), '%')\n", + "print(round(100 * all_rides['August'] / sum(all_rides.values()),2), '%') # zaokrąglenie" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "Napisz kod, który zwraci tzw. \"Big 'NO!'\" (zob. http://tvtropes.org/pmwiki/pmwiki.php/Main/BigNo)\n", + "dla zadanej liczby tj. napis typu \"NOOOOOOOOOOOOO!\", gdzie liczba 'O' ma być\n", + "równa wartości zmniennej `number_of_o`. Jeśli argument jest mniejszy niż 5, ma być zwracany napis \"It's not a Big 'No!'\".\n", + "Wyświetl ten napis na ekran.\n", + "\"\"\"\n", + "\n", + "number_of_o = 6" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NOOOOOO!\n" + ] + } + ], + "source": [ + "if number_of_o < 5:\n", + " print(\"It's not a Big 'No!'\")\n", + "else:\n", + " print(\"N\"+\"O\"*number_of_o+'!')" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + " * Podziel zmienną `text` na słowa, korzystając z metody split.\n", + " * Dodaj do listy `oov`, wszystkie słowa (bez powtórzeń), które nie są zawarte w liście `vocab`.\n", + "\"\"\"\n", + "\n", + "\n", + "text = \"this is a string , which i will use for string testing\"\n", + "vocab = [',', 'this', 'is', 'a', 'which', 'for', 'will', 'i']\n", + "\n", + "oov = []\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['string', 'use', 'testing']" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "text_splitted = text.split()\n", + "text_splitted_no_repeats = set(text_splitted)\n", + "\n", + "for item in text_splitted_no_repeats:\n", + " if item not in vocab:\n", + " oov.append(item)\n", + " \n", + "oov" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\n1. Napisz rekurencyjną funkcję, która zwróci n-ty wyraz ciągu Fibonacciego.\\n2. Napisz funkcję, która obliczy n-ty wyroz ciągu Fibonacciego nie korzystając z rekurencji.\\nNp. możesz wykorzystać listę do obliczania kolejnych wartości ciągu.\\n\\nCiąg Fibonacciego:\\na[0] = 1, a[1] = 1, a[n] = a[n-1] + a[n-2] dla n>=2\\n\\n'" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "1. Napisz rekurencyjną funkcję, która zwróci n-ty wyraz ciągu Fibonacciego.\n", + "2. Napisz funkcję, która obliczy n-ty wyroz ciągu Fibonacciego nie korzystając z rekurencji.\n", + "Np. możesz wykorzystać listę do obliczania kolejnych wartości ciągu.\n", + "\n", + "Ciąg Fibonacciego:\n", + "a[0] = 1, a[1] = 1, a[n] = a[n-1] + a[n-2] dla n>=2\n", + "\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "89" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def fib(n):\n", + " if n == 0:\n", + " return 1\n", + " elif n == 1:\n", + " return 1\n", + " else:\n", + " return fib(n-1) + fib(n-2)\n", + "fib(10)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\"\"\"\n", + "Napisz funkcję sum_div35(n), która zwraca sumę wszystkich liczb podzielnych\n", + "przez 3 lub 5 mniejszych niż n.\n", + "\"\"\"\n", + "\n", + "def sum_div35(n):\n", + " pass\n", + "\n", + "input = 100\n", + "# dla n =100 poprawna odpowiedź to 2318\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2318" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def sum_div35(n):\n", + " all_numbers = []\n", + " for i in range(n):\n", + " if i % 3 == 0 or i % 5 == 0:\n", + " all_numbers.append(i)\n", + " return sum(all_numbers)\n", + "\n", + "sum_div35(100)\n", + "\n", + "# alternatywnie:\n", + "def sum_div35(n):\n", + " return sum([i for i in range(n) if i % 3 == 0 or i % 5 == 0 ])\n", + "sum_div35(100)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nOtwórz plik `zen_of_python.txt` i zlicz liczbę linii i słów w tym pliku. \\nNastępnie przerób kod na funkcję, która jako argument będzie przyjmować ściężkę do pliku i będzie zwracać \\nsłownik z dwoma kluczami: `liczba_linii` i `liczba_slow`.\\n'" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "Otwórz plik `zen_of_python.txt` i zlicz liczbę linii i słów w tym pliku. \n", + "Następnie przerób kod na funkcję, która jako argument będzie przyjmować ściężkę do pliku i będzie zwracać \n", + "słownik z dwoma kluczami: `liczba_linii` i `liczba_slow`.\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "19\n" + ] + }, + { + "data": { + "text/plain": [ + "(19, 137)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(len(open('zen_of_python.txt').readlines()))\n", + "\n", + "def count_lines_and_words(path):\n", + " lines = 0\n", + " words = 0\n", + " with open(path) as f:\n", + " for line in f:\n", + " lines += 1\n", + " words += len(line.split())\n", + " return lines, words\n", + "\n", + "count_lines_and_words('zen_of_python.txt')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "Zadania: Zaimportuj bibliotekę statistics, która zawiera funckje do obliczenia podstawych wielkości statystycznych (średnia, mediana, moda):\n", + " statistics.mean -- obliczenie średniej\n", + " statistics.median -- obliczenie mediany\n", + " statistics.variance -- obliczenie wariancji\n", + " statistics.stdev -- obliczenie odchylenia standardowego Oblicz te wielkości dla wartości z poniższego słownika.\n", + "Każda z tych funkcji przyjmuje jeden argument: listę wartości.\n", + "\"\"\"\n", + "\n", + "members = {\n", + " 'April': 211819,\n", + " 'May': 682758,\n", + " 'June': 737011,\n", + " 'July': 779511,\n", + " 'August': 673790,\n", + " 'September': 673790,\n", + " 'October': 444177,\n", + " 'November': 136791,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "542455.875\n", + "673790.0\n", + "61681755885.83929\n", + "248358.12023334226\n" + ] + } + ], + "source": [ + "import statistics\n", + "\n", + "values = members.values()\n", + "\n", + "print(statistics.mean(values))\n", + "print(statistics.median(values))\n", + "print(statistics.variance(values))\n", + "print(statistics.stdev(values))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "Biblioteka random posiada funkcję random, która zwraca losową licznę z przedziału [0, 1) (nie przyjmuje żadnych argumentów).\n", + "Biblioteka math posiada funkcję hypot, która oblicza odległość punktu od środka układu współrzędnych (punktu [0, 0]) i przyjmuje dwa argumenty: współrzędne punktu.\n", + "* Zaimportuj biblioteki random i math\n", + "* korzystając z funkcji random wylosuj dwie liczby i przypisz wyniki do zmniennych x i y.\n", + "* Korzystając z funkcji hypot oblicz odległość punktu o współrzednych (x,y).\n", + "* Dodaj pętlę, która będzie wykonywać te czynności n = 10 razy i będzie zliczać ile razy obliczona odległość jest mniejsza od 1.\n", + "* Oblicz stosunek liczby punktów, dla których odległość wynosiła mniej niż 1 do całkowitej liczby punktów. Pomnóż tę wartocść przez 4.\n", + "* Podstaw za n wartości 100, 1000, 1000000. Do jakiej wartości zbiegają wartości?\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.023482041105784\n", + "785667\n", + "3.142668\n" + ] + } + ], + "source": [ + "import random\n", + "import math\n", + "\n", + "x,y = random.random(), random.random()\n", + "print(math.hypot(x,y))\n", + "\n", + "n = 1000000\n", + "lower_than_1_number = 0\n", + "for i in range(n):\n", + " x,y = random.random(), random.random()\n", + " if math.hypot(x,y) < 1 :\n", + " lower_than_1_number +=1\n", + "print(lower_than_1_number)\n", + "\n", + "print((lower_than_1_number / n )*4)\n", + "\n", + "# zmierza do stałej PI" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "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": 4 +}