{ "nbformat": 4, "nbformat_minor": 0, "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.7.6" }, "colab": { "name": "kl_py_pandas_02.ipynb", "provenance": [], "collapsed_sections": [], "include_colab_link": true } }, "cells": [ { "cell_type": "markdown", "metadata": { "id": "view-in-github", "colab_type": "text" }, "source": [ "\"Open" ] }, { "cell_type": "markdown", "metadata": { "id": "Bw4GE_218lYe", "colab_type": "text" }, "source": [ "

\n", " \n", " \n", "

\n", "\n", "\n", "

\n", "\n", "# Pandas bevezető 2.\n", "\n", "https://klajosw.blogspot.com/\n", "\n", "https://github.com/klajosw/\n", "\n", "pandas: NumPy-ra épülő adatfeldolgozó és elemző eszköz\n", "\n", "---" ] }, { "cell_type": "code", "metadata": { "id": "LrahWQTJ8lYf", "colab_type": "code", "colab": {} }, "source": [ "from datetime import datetime\n", "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline" ], "execution_count": 0, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "6ey1dG8c8lYj", "colab_type": "code", "outputId": "497dbe32-7e55-4a55-e820-131b5165f9cd", "colab": { "base_uri": "https://localhost:8080/", "height": 334 } }, "source": [ "# DataFrame-et létre lehet hozni szótárból...\n", "data1 = {\"a\": [1, 1, 2], \"b\": [3.0, 4.0, None]}\n", "df1 = pd.DataFrame(data1)\n", "print('Szótárból: ')\n", "print(df1)\n", "print('-----------------')\n", "\n", "# ...sztring-lista párok listájából\n", "data2 = [(\"a\", [1, 1, 2]), (\"b\", [3.0, 4.0, None])]\n", "df2 = pd.DataFrame.from_dict(dict(data2))\n", "print('String Listapárból: ')\n", "print(df2)\n", "print('-----------------')\n", "\n", "# ...szótárak listájából\n", "data3 = [{\"a\": 1, \"b\": 3}, {\"a\": 1, \"b\": 4}, {\"a\": 2}]\n", "df3 = pd.DataFrame(data3)\n", "print('Szótárak listájából: ')\n", "print(df3)\n", "print('-----------------')\n", "\n", "# ...és még számos egyéb módon\n" ], "execution_count": 5, "outputs": [ { "output_type": "stream", "text": [ "Szótárból: \n", " a b\n", "0 1 3.0\n", "1 1 4.0\n", "2 2 NaN\n", "-----------------\n", "String Listapárból: \n", " a b\n", "0 1 3.0\n", "1 1 4.0\n", "2 2 NaN\n", "-----------------\n", "Szótárak listájából: \n", " a b\n", "0 1 3.0\n", "1 1 4.0\n", "2 2 NaN\n", "-----------------\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "id": "J3kwMblW8lYn", "colab_type": "code", "outputId": "24ce45aa-2dec-44a3-c532-29181702fb8c", "colab": { "base_uri": "https://localhost:8080/", "height": 70 } }, "source": [ "## egyszerű elem kimetszés\n", "def slices(s, *args): ## Kimetsző\n", " position = 0 ## Kezdő pozició\n", " for length in args:\n", " yield s[position:position + length] \n", "# a yield egy különleges függvény, amely időről időre értékeket állít elő, mint egy folytatható függvény, a meghívása egy generátort ad vissza\n", " \n", "print(list(slices('abcdefghijklmnopqrstuvwxyz0123456789', 2, 10, 50)))\n", "print('---------------------------')\n", "d,c,h = slices('LajosBélaAttilaFeri', 5, 4, 6)\n", "print(d,c,h)\n" ], "execution_count": 8, "outputs": [ { "output_type": "stream", "text": [ "['ab', 'abcdefghij', 'abcdefghijklmnopqrstuvwxyz0123456789']\n", "---------------------------\n", "Lajos Lajo LajosB\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "Kj3NjSMwLuOQ", "colab_type": "text" }, "source": [ "---\n", "\n", "## yield utasítás\n", "\n", "Ezt akkor használjuk, amikor egy generátor függvényt definiálunk és csak a függvény törzsében használjuk. \n", "\n", "A yield utasítás használata egy függvény definiálásánál elegendő ahhoz, hogy egy normál függvényből egy generátor függvényt készítsünk.\n", "\n", "Amikor a generátor függvényt meghívjuk, akkor visszatér egy iterátorral, amit generátor iterátornak, vagy másképp generátornak nevezünk. \n", "\n", "A generátor next() hívásának hatására a függvény törzse híváskor hajtódik végre, és addig ismétlődik, amíg egy kivételt nem vált ki.\n", "\n", "A yield utasítás végrehajtásakor, a generátor állapota fagyott lesz, és a kifejezés lista értékével tér vissza next() hívójához. \n", "\n", "\n", "---" ] }, { "cell_type": "code", "metadata": { "id": "Jwn39oZdI8L1", "colab_type": "code", "colab": { "base_uri": "https://localhost:8080/", "height": 52 }, "outputId": "819809f6-f61c-488e-841c-178bf61b4214" }, "source": [ "## yield minta\n", "def fib(max):\n", " a, b = 0, 1 \n", " while a < max:\n", " yield a ## yield Generátort ad vissza, csak a meghívásakor töltődik fel \n", " a, b = b, a + b \n", "\n", "print('Fibonacci sor lista bejárása: ') \n", "for n in fib(200): ## Generátoros függvény meghívása és for ciklusban olvasása és kiírása \n", " print(n, end=' ') \n" ], "execution_count": 17, "outputs": [ { "output_type": "stream", "text": [ "Fibonacci sor lista bejárása: \n", "0 1 1 2 3 5 8 13 21 34 55 89 144 " ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "id": "_kHeRA4T8lYp", "colab_type": "code", "outputId": "04a19c71-7c63-445f-84d1-dee29a568e98", "colab": { "base_uri": "https://localhost:8080/", "height": 52 } }, "source": [ "# minden DataFrame-hez és Series-hez tartozik index\n", "print(df1.index)\n", "# (alapértelmezés szerint az index 0-tól induló, 1-esével növekedő sorszám)\n", "\n", "# ...de természetesen mást is megadhatunk indexnek\n", "df4 = pd.DataFrame(data1, [\"xx\", \"yy\", \"zz\"])\n", "print(df4.index)\n", "\n", "#Int64Index([0, 1, 2], dtype='int64')\n", "#Index(['xx', 'yy', 'zz'], dtype='object')\n" ], "execution_count": 18, "outputs": [ { "output_type": "stream", "text": [ "RangeIndex(start=0, stop=3, step=1)\n", "Index(['xx', 'yy', 'zz'], dtype='object')\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "id": "ImpoVp7v8lYs", "colab_type": "code", "outputId": "0f131df7-5f21-4778-e4a0-59cb1decc226", "colab": { "base_uri": "https://localhost:8080/", "height": 87 } }, "source": [ "\n", "\n", "# példák Series létrehozásra:\n", "se1 = pd.Series([2, 3, 4])\n", "se2 = pd.Series([2, 3, 4], [\"xx\", \"yy\", \"zz\"]) # a 2. argumentum az index\n", "\n", "# DataFrame-ből oszlopot [] operátorral lehet kiválasztani\n", "df1[\"a\"] # <= Series-t ad eredményül\n", "# ...illetve ha az oszlop neve érvényes azonosítónév, akkor . operátorral is\n", "df1.a # <= Series-t ad eredményül\n" ], "execution_count": 19, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "0 1\n", "1 1\n", "2 2\n", "Name: a, dtype: int64" ] }, "metadata": { "tags": [] }, "execution_count": 19 } ] }, { "cell_type": "code", "metadata": { "id": "Y0WfqCDk8lYv", "colab_type": "code", "outputId": "33bb0e79-e183-486a-b3b3-2ae46dbed343", "colab": { "base_uri": "https://localhost:8080/", "height": 106 } }, "source": [ "# DataFrame-ből sort a .iloc attribútumon keresztül lehet kiválasztani\n", "df1.iloc[0] # <= ez is Series-t ad eredményül\n", "df1.iloc[[1, 0]] # <= DataFrame-et ad eredményül, mivel 2 sort választottunk ki" ], "execution_count": 20, "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
ab
114.0
013.0
\n", "
" ], "text/plain": [ " a b\n", "1 1 4.0\n", "0 1 3.0" ] }, "metadata": { "tags": [] }, "execution_count": 20 } ] }, { "cell_type": "code", "metadata": { "id": "eQg3w0Bd8lYy", "colab_type": "code", "outputId": "9491448c-ba52-42a2-ab04-0be1cae49621", "colab": { "base_uri": "https://localhost:8080/", "height": 70 } }, "source": [ "# Series-ből elemet [] operátorral lehet kiválasztani\n", "print(se1[0])\n", "print(se2[\"xx\"])\n", "\n", "# a nyers adattartalmát a values attribútumon keresztül lehet elérni\n", "se1.values # <= numpy tömböt ad eredményül" ], "execution_count": 21, "outputs": [ { "output_type": "stream", "text": [ "2\n", "2\n" ], "name": "stdout" }, { "output_type": "execute_result", "data": { "text/plain": [ "array([2, 3, 4])" ] }, "metadata": { "tags": [] }, "execution_count": 21 } ] }, { "cell_type": "code", "metadata": { "id": "9ADZnwSV8lY1", "colab_type": "code", "outputId": "feaf9ba5-6511-479a-8e07-42c4be8c5740", "colab": {} }, "source": [ "# Import\n", "#import pandas as pd\n", "#import numpy as np\n", "\n", "path = r'c:\\Users\\User\\Documents\\mintak\\jupiter\\kl\\aa_kl_2020\\fixlinefile.txt'\n", "\n", "# Using Pandas with a column specification\n", "col_specification = [(0, 9), (10, 18), (19, 27), (29, 36), (38, 45), (46, 100)]\n", "data = pd.read_fwf(path, colspecs=col_specification) ## Read a table of fixed-width formatted lines into DataFrame.\n", "#print(data.dtypes)\n", "#print(data.columns) ## Index(['ncalls', 'tottime', 'percall', 'cumtime', 'percall.1', 'filename:lineno(function)'], dtype='object')\n", "#print(data.index) ## RangeIndex(start=0, stop=10, step=1)\n", "\n", "print(data.describe()) ## adatframe info\n", "print('---------------------------')\n", "print(data['ncalls'].min())\n", "print(data['ncalls'].max())\n", "print('---------------------------')\n", "print(data['ncalls'].describe()) ## adatframe egy mezőről info\n", "print('---------------------------')\n", "\n", "\n", "print('---------------------------')\n", "print(data)\n", "print('---------------------------')\n", "\n", " \n", "## kiírás filebe\n", "data.to_csv('kimenet.csv', sep='|') ## separátorok lehetnek még: | \\t , ; ¤ @ ~\n", "\n", "## diagram\n", "data[['cumtime', 'percall']].plot(figsize=(10, 6), style=['-', '--'], lw=2)" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ " tottime apercall cumtime percall\n", "count 10.000000 10.000000 10.000000 10.000000\n", "mean 0.001100 0.000300 0.012400 0.006300\n", "std 0.002601 0.000949 0.005296 0.009166\n", "min 0.000000 0.000000 0.008000 0.000000\n", "25% 0.000000 0.000000 0.009000 0.000000\n", "50% 0.000000 0.000000 0.011000 0.000000\n", "75% 0.000000 0.000000 0.012500 0.010250\n", "max 0.008000 0.003000 0.022000 0.022000\n", "---------------------------\n", "1\n", "50\n", "---------------------------\n", "count 10\n", "unique 3\n", "top 50\n", "freq 5\n", "Name: ncalls, dtype: object\n", "---------------------------\n", "---------------------------\n", " ncalls tottime apercall cumtime percall \\\n", "0 1 0.000 0.000 0.022 0.022 \n", "1 1 0.000 0.000 0.022 0.022 \n", "2 354/52 0.000 0.000 0.013 0.000 \n", "3 1 0.000 0.000 0.011 0.011 \n", "4 50 0.000 0.000 0.011 0.000 \n", "5 50 0.000 0.000 0.011 0.000 \n", "6 50 0.000 0.000 0.009 0.000 \n", "7 50 0.000 0.000 0.009 0.000 \n", "8 50 0.008 0.000 0.008 0.000 \n", "9 1 0.003 0.003 0.008 0.008 \n", "\n", " filename:lineno(function) \n", "0 {built-in method builtins.exec} \n", "1 :5() \n", "2 {built-in method numpy.core._multiarray_umath.... \n", "3 :9() \n", "4 <__array_function__ internals>:2(histogram) \n", "5 histograms.py:680(histogram) \n", "6 <__array_function__ internals>:2(sort) \n", "7 fromnumeric.py:837(sort) \n", "8 {method 'sort' of 'numpy.ndarray' objects} \n", "9 :1(step) \n", "---------------------------\n" ], "name": "stdout" }, { "output_type": "display_data", "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } } ] }, { "cell_type": "code", "metadata": { "id": "9eaoQqmu8lY3", "colab_type": "code", "outputId": "825a9323-b709-4a91-87a0-ea17e0f85a4a", "colab": {} }, "source": [ "# Az openair.csv fájl London légszennyezetttségéről tartalmaz adatokat.\n", "# Töltsük be a fájlt DataFrame-be!\n", "url = \"https://github.com/ipython-books/cookbook-2nd-data/blob/master/federer.csv?raw=true\"\n", "\n", "df = pd.read_csv(url)\n", "print(df.head(3)) ## három sor liíratása\n", "print('-------------')\n", "\n", "# Megjegyzések:\n", "# - a pandas.read_csv függvénynek rengeteg paramétere van,\n", "# hogy be tudja tölteni a valós életben előforduló CSV fájl változatokat\n", "# - a pandas képes kezelni a hiányzó adatokat\n", "# (ezek a táblában NaN értékként jelennek meg)\n", "\n", "# így tudunk összesítő információkat kérni a DataFrame-ről\n", "df.info()" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ " year tournament start date type surface draw \\\n", "0 1998 Basel, Switzerland 05.10.1998 WS Indoor: Hard Draw: 32 \n", "1 1998 Toulouse, France 28.09.1998 WS Indoor: Hard Draw: 32 \n", "2 1998 Toulouse, France 28.09.1998 WS Indoor: Hard Draw: 32 \n", "\n", " atp points atp ranking tournament prize money round ... \\\n", "0 1 396.0 $9,800 R32 ... \n", "1 59 878.0 $10,800 R32 ... \n", "2 59 878.0 $10,800 R16 ... \n", "\n", " player2 2nd serve return points total player2 break points converted won \\\n", "0 22.0 4.0 \n", "1 19.0 0.0 \n", "2 30.0 0.0 \n", "\n", " player2 break points converted total player2 return games played \\\n", "0 8.0 8.0 \n", "1 1.0 8.0 \n", "2 4.0 10.0 \n", "\n", " player2 total service points won player2 total service points total \\\n", "0 36.0 50.0 \n", "1 33.0 65.0 \n", "2 46.0 75.0 \n", "\n", " player2 total return points won player2 total return points total \\\n", "0 26.0 53.0 \n", "1 8.0 41.0 \n", "2 23.0 73.0 \n", "\n", " player2 total points won player2 total points total \n", "0 62.0 103.0 \n", "1 41.0 106.0 \n", "2 69.0 148.0 \n", "\n", "[3 rows x 70 columns]\n", "-------------\n", "\n", "RangeIndex: 1179 entries, 0 to 1178\n", "Data columns (total 70 columns):\n", "year 1179 non-null int64\n", "tournament 1179 non-null object\n", "start date 1179 non-null object\n", "type 1179 non-null object\n", "surface 1179 non-null object\n", "draw 1179 non-null object\n", "atp points 1139 non-null object\n", "atp ranking 1177 non-null float64\n", "tournament prize money 1170 non-null object\n", "round 1179 non-null object\n", "opponent 1179 non-null object\n", "ranking 1105 non-null object\n", "score 1179 non-null object\n", "stats link 1179 non-null object\n", "tournament.1 1179 non-null object\n", "tournament round 1179 non-null object\n", "time 1179 non-null int64\n", "winner 1179 non-null object\n", "player1 name 1179 non-null object\n", "player1 nationality 1179 non-null object\n", "player1 aces 1027 non-null float64\n", "player1 double faults 1027 non-null float64\n", "player1 1st serves in 1027 non-null float64\n", "player1 1st serves total 1027 non-null float64\n", "player1 1st serve points won 1027 non-null float64\n", "player1 1st serve points total 1027 non-null float64\n", "player1 2nd serve points won 1027 non-null float64\n", "player1 2nd serve points total 1027 non-null float64\n", "player1 break points won 1027 non-null float64\n", "player1 break points total 1027 non-null float64\n", "player1 service games played 1027 non-null float64\n", "player1 1st serve return points won 1027 non-null float64\n", "player1 1st serve return points total 1027 non-null float64\n", "player1 2nd serve return points won 1027 non-null float64\n", "player1 2nd serve return points total 1027 non-null float64\n", "player1 break points converted won 1027 non-null float64\n", "player1 break points converted total 1027 non-null float64\n", "player1 return games played 1027 non-null float64\n", "player1 total service points won 1027 non-null float64\n", "player1 total service points total 1027 non-null float64\n", "player1 total return points won 1027 non-null float64\n", "player1 total return points total 1027 non-null float64\n", "player1 total points won 1027 non-null float64\n", "player1 total points total 1027 non-null float64\n", "player2 name 1179 non-null object\n", "player2 nationality 1110 non-null object\n", "player2 aces 1027 non-null float64\n", "player2 double faults 1027 non-null float64\n", "player2 1st serves in 1027 non-null float64\n", "player2 1st serves total 1027 non-null float64\n", "player2 1st serve points won 1027 non-null float64\n", "player2 1st serve points total 1027 non-null float64\n", "player2 2nd serve points won 1027 non-null float64\n", "player2 2nd serve points total 1027 non-null float64\n", "player2 break points won 1027 non-null float64\n", "player2 break points total 1027 non-null float64\n", "player2 service games played 1027 non-null float64\n", "player2 1st serve return points won 1027 non-null float64\n", "player2 1st serve return points total 1027 non-null float64\n", "player2 2nd serve return points won 1027 non-null float64\n", "player2 2nd serve return points total 1027 non-null float64\n", "player2 break points converted won 1027 non-null float64\n", "player2 break points converted total 1027 non-null float64\n", "player2 return games played 1027 non-null float64\n", "player2 total service points won 1027 non-null float64\n", "player2 total service points total 1027 non-null float64\n", "player2 total return points won 1027 non-null float64\n", "player2 total return points total 1027 non-null float64\n", "player2 total points won 1027 non-null float64\n", "player2 total points total 1027 non-null float64\n", "dtypes: float64(49), int64(2), object(19)\n", "memory usage: 644.9+ KB\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "id": "otb2kzs_8lY6", "colab_type": "code", "outputId": "7481a506-bfc1-484d-f9be-c3ce727bbe95", "colab": {} }, "source": [ "# írassuk ki az oszlopok minimális, maximális és és átlagos értékét\n", "data = []\n", "for c in df.columns[22:30]: # kihagyjuk a dátum oszlopot, mivel ott nincs értelme az átlagnak\n", " se = df[c]\n", " data.append({\"column\": c, \"min\": se.min(), \"max\": se.max(), \"mean\": se.mean()})\n", " # (megjegyzés: a pandas a NaN értékeket nem veszi figyelembe a statisztikakészítéskor)\n", "stats = pd.DataFrame(data)\n", "stats\n", "\n", "# megjegyzés: a statisztikákat a describe() függvény segítségével is lekérhettük volna\n", "print(df[\"player1 aces\"].describe()) # <= egy oszlop statisztikáit adja vissza (Series-be csomagolva)\n", "\n", "df.describe() # <= az összes oszlop statisztikáit visszaadja (DataFrame-be csomagolva)\n", "\n", "df[\"player1 aces\"][:10].plot()" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "count 1027.000000\n", "mean 7.658228\n", "std 4.791261\n", "min 0.000000\n", "25% 4.000000\n", "50% 7.000000\n", "75% 10.000000\n", "max 50.000000\n", "Name: player1 aces, dtype: float64\n" ], "name": "stdout" }, { "output_type": "execute_result", "data": { "text/plain": [ "" ] }, "metadata": { "tags": [] }, "execution_count": 50 }, { "output_type": "display_data", "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } } ] }, { "cell_type": "code", "metadata": { "id": "1-HbhXpw8lY8", "colab_type": "code", "outputId": "1f7d50d4-3afa-452c-d869-7b8cbd29064c", "colab": {} }, "source": [ "player = 'Roger Federer'\n", "df['win'] = df['winner'] == player\n", "df['win'].tail()" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "1174 False\n", "1175 True\n", "1176 True\n", "1177 True\n", "1178 False\n", "Name: win, dtype: bool" ] }, "metadata": { "tags": [] }, "execution_count": 52 } ] }, { "cell_type": "code", "metadata": { "id": "K553OH798lY_", "colab_type": "code", "outputId": "8caae763-9391-4bf8-9fee-ff63bee9d490", "colab": {} }, "source": [ "won = 100 * df['win'].mean()\n", "print(f\"{player} {won:.0f}% -ban győzött a mérkőzései során.\")" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Roger Federer 82% -ban győzött a mérkőzései során.\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "id": "B_RZMXwJ8lZB", "colab_type": "code", "outputId": "29377823-4141-42c4-ef72-9b2da5d3e2b5", "colab": {} }, "source": [ "date = df['start date']\n", "print(date)\n", "print('------------------')\n", "df['dblfaults'] = (df['player1 double faults'] / df['player1 total points total'])\n", "print(df['dblfaults'].tail())\n", "print('------------------')\n", "print(df['dblfaults'].describe())" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "0 05.10.1998\n", "1 28.09.1998\n", "2 28.09.1998\n", "3 28.09.1998\n", "4 24.08.1998\n", " ... \n", "1174 16.01.2012\n", "1175 02.01.2012\n", "1176 02.01.2012\n", "1177 02.01.2012\n", "1178 02.01.2012\n", "Name: start date, Length: 1179, dtype: object\n", "------------------\n", "1174 0.018116\n", "1175 0.000000\n", "1176 0.000000\n", "1177 0.011561\n", "1178 NaN\n", "Name: dblfaults, dtype: float64\n", "------------------\n", "count 1027.000000\n", "mean 0.012129\n", "std 0.010797\n", "min 0.000000\n", "25% 0.004444\n", "50% 0.010000\n", "75% 0.018108\n", "max 0.060606\n", "Name: dblfaults, dtype: float64\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "id": "GSiU4JSo8lZD", "colab_type": "code", "outputId": "6d5341af-0108-4362-9627-9d83d9a5fb5f", "colab": {} }, "source": [ "## milyen tipusú pályákon volt eredményes\n", "df.groupby('surface')['win'].mean()" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "surface\n", "Indoor: Carpet 0.736842\n", "Indoor: Clay 0.833333\n", "Indoor: Hard 0.836283\n", "Outdoor: Clay 0.779116\n", "Outdoor: Grass 0.871429\n", "Outdoor: Hard 0.842324\n", "Name: win, dtype: float64" ] }, "metadata": { "tags": [] }, "execution_count": 67 } ] }, { "cell_type": "code", "metadata": { "id": "IiKhm0Xo8lZG", "colab_type": "code", "outputId": "b9c36ab5-2132-4d56-b93d-cd113c2b78b7", "colab": {} }, "source": [ "from datetime import datetime\n", "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", "\n", "gb = df.groupby('year')\n", "\n", "\n", "fig, ax = plt.subplots(1, 1)\n", "ax.plot_date(date, df['dblfaults'], alpha=.25, lw=0)\n", "ax.plot_date(gb['start date'].max(), gb['dblfaults'].mean(), '-', lw=3)\n", "ax.set_xlabel('Year')\n", "ax.set_ylabel('Double faults per match')\n", "ax.set_ylim(0)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "(0, 0.06363636363636364)" ] }, "metadata": { "tags": [] }, "execution_count": 74 }, { "output_type": "display_data", "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } } ] }, { "cell_type": "code", "metadata": { "id": "vYWz-H2u8lZI", "colab_type": "code", "colab": {} }, "source": [ "" ], "execution_count": 0, "outputs": [] } ] }