├── .gitignore ├── 00 resources ├── Dash Deployment.docx ├── Deloitte_logo.png ├── Exploring the example dataset.ipynb ├── Virginia.csv ├── requirements.txt └── titanic.csv ├── 01 Plotly figures ├── Exploring the example dataset.ipynb ├── Plotly figure basics.ipynb ├── Plotly figures with Pandas.ipynb └── virginia-voter-data.ipynb ├── 02 basic dashboards ├── barchart_v1.py ├── barchart_v2.py ├── header and logo.py ├── helloworld.py ├── simple_flask.py └── two_charts.py ├── 03 callbacks ├── callback with state.py ├── simple callback.py └── slider.py ├── 04 visualize pandas ├── pandas_example1.py ├── pandas_example2.py ├── table_format_new.py └── table_format_old.py ├── 05 tabs and pages ├── multi-page app │ ├── home.py │ ├── multipage_app.py │ └── pages │ │ ├── __init__.py │ │ ├── index.py │ │ ├── page_1.py │ │ └── page_2.py └── multi-tab app │ ├── main.py │ └── tabs │ ├── tab_1.py │ └── tab_2.py ├── 06 Heroku examples └── list of resources.md └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | .ipynb_checkpoints 3 | .pyc 4 | __pycache__ 5 | -------------------------------------------------------------------------------- /00 resources/Dash Deployment.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/austinlasseter/plotly_dash_tutorial/f7ac5540ee970d7ac77f0fc1273f2ab670d1bb9d/00 resources/Dash Deployment.docx -------------------------------------------------------------------------------- /00 resources/Deloitte_logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/austinlasseter/plotly_dash_tutorial/f7ac5540ee970d7ac77f0fc1273f2ab670d1bb9d/00 resources/Deloitte_logo.png -------------------------------------------------------------------------------- /00 resources/Exploring the example dataset.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### A quick exploration of the example dataset" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "import numpy as np\n", 17 | "import pandas as pd\n", 18 | "import seaborn as sns\n", 19 | "import matplotlib.pyplot as plt\n", 20 | "%matplotlib inline" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 2, 26 | "metadata": {}, 27 | "outputs": [ 28 | { 29 | "data": { 30 | "text/plain": [ 31 | "(891, 12)" 32 | ] 33 | }, 34 | "execution_count": 2, 35 | "metadata": {}, 36 | "output_type": "execute_result" 37 | } 38 | ], 39 | "source": [ 40 | "# Read in the source data from Kaggle\n", 41 | "url=\"https://raw.githubusercontent.com/agconti/kaggle-titanic/master/data/train.csv\"\n", 42 | "df=pd.read_csv(url)\n", 43 | "df.shape" 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": 3, 49 | "metadata": {}, 50 | "outputs": [ 51 | { 52 | "data": { 53 | "text/plain": [ 54 | "(712, 6)" 55 | ] 56 | }, 57 | "execution_count": 3, 58 | "metadata": {}, 59 | "output_type": "execute_result" 60 | } 61 | ], 62 | "source": [ 63 | "# Keep only a few columns, and drop missing values\n", 64 | "df = df[['Survived', 'Pclass', 'Sex', 'Age', 'Fare', 'Embarked']]\n", 65 | "df.dropna(how='any', inplace=True);\n", 66 | "df.shape" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 4, 72 | "metadata": {}, 73 | "outputs": [ 74 | { 75 | "data": { 76 | "text/plain": [ 77 | "Southampton 554\n", 78 | "Cherbourg 130\n", 79 | "Queenstown 28\n", 80 | "Name: Embarked, dtype: int64" 81 | ] 82 | }, 83 | "execution_count": 4, 84 | "metadata": {}, 85 | "output_type": "execute_result" 86 | } 87 | ], 88 | "source": [ 89 | "# Let's spell out the port of embarcation\n", 90 | "df.loc[(df['Embarked']=='C') , 'Embarked']='Cherbourg'\n", 91 | "df.loc[(df['Embarked']=='Q') , 'Embarked']='Queenstown'\n", 92 | "df.loc[(df['Embarked']=='S') , 'Embarked']='Southampton'\n", 93 | "df['Embarked'].value_counts()" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": 5, 99 | "metadata": {}, 100 | "outputs": [ 101 | { 102 | "name": "stdout", 103 | "output_type": "stream", 104 | "text": [ 105 | "int64\n" 106 | ] 107 | }, 108 | { 109 | "data": { 110 | "text/plain": [ 111 | "1 184\n", 112 | "2 173\n", 113 | "3 355\n", 114 | "Name: Pclass, dtype: int64" 115 | ] 116 | }, 117 | "execution_count": 5, 118 | "metadata": {}, 119 | "output_type": "execute_result" 120 | } 121 | ], 122 | "source": [ 123 | "# Convert Pclass to a numeric format, and sort it\n", 124 | "df['Pclass'] = pd.to_numeric(df['Pclass'], errors='coerce').fillna(0).astype(np.int64);\n", 125 | "print(df['Pclass'].dtype)\n", 126 | "df['Pclass'].value_counts().sort_index()" 127 | ] 128 | }, 129 | { 130 | "cell_type": "markdown", 131 | "metadata": {}, 132 | "source": [ 133 | "## Basic value counts" 134 | ] 135 | }, 136 | { 137 | "cell_type": "code", 138 | "execution_count": 6, 139 | "metadata": {}, 140 | "outputs": [ 141 | { 142 | "data": { 143 | "text/html": [ 144 | "
\n", 145 | "\n", 158 | "\n", 159 | " \n", 160 | " \n", 161 | " \n", 162 | " \n", 163 | " \n", 164 | " \n", 165 | " \n", 166 | " \n", 167 | " \n", 168 | " \n", 169 | " \n", 170 | " \n", 171 | " \n", 172 | " \n", 173 | " \n", 174 | " \n", 175 | " \n", 176 | " \n", 177 | " \n", 178 | " \n", 179 | " \n", 180 | " \n", 181 | " \n", 182 | " \n", 183 | " \n", 184 | " \n", 185 | " \n", 186 | " \n", 187 | " \n", 188 | " \n", 189 | " \n", 190 | " \n", 191 | " \n", 192 | " \n", 193 | " \n", 194 | " \n", 195 | " \n", 196 | " \n", 197 | " \n", 198 | " \n", 199 | " \n", 200 | " \n", 201 | " \n", 202 | " \n", 203 | " \n", 204 | " \n", 205 | " \n", 206 | " \n", 207 | " \n", 208 | " \n", 209 | " \n", 210 | " \n", 211 | " \n", 212 | " \n", 213 | " \n", 214 | " \n", 215 | " \n", 216 | " \n", 217 | "
SurvivedPclassSexAgeFareEmbarked
003male22.07.2500Southampton
111female38.071.2833Cherbourg
213female26.07.9250Southampton
311female35.053.1000Southampton
403male35.08.0500Southampton
\n", 218 | "
" 219 | ], 220 | "text/plain": [ 221 | " Survived Pclass Sex Age Fare Embarked\n", 222 | "0 0 3 male 22.0 7.2500 Southampton\n", 223 | "1 1 1 female 38.0 71.2833 Cherbourg\n", 224 | "2 1 3 female 26.0 7.9250 Southampton\n", 225 | "3 1 1 female 35.0 53.1000 Southampton\n", 226 | "4 0 3 male 35.0 8.0500 Southampton" 227 | ] 228 | }, 229 | "execution_count": 6, 230 | "metadata": {}, 231 | "output_type": "execute_result" 232 | } 233 | ], 234 | "source": [ 235 | "df.head()" 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": 7, 241 | "metadata": {}, 242 | "outputs": [ 243 | { 244 | "data": { 245 | "text/plain": [ 246 | "Index(['Survived', 'Pclass', 'Sex', 'Age', 'Fare', 'Embarked'], dtype='object')" 247 | ] 248 | }, 249 | "execution_count": 7, 250 | "metadata": {}, 251 | "output_type": "execute_result" 252 | } 253 | ], 254 | "source": [ 255 | "df.columns" 256 | ] 257 | }, 258 | { 259 | "cell_type": "code", 260 | "execution_count": 8, 261 | "metadata": {}, 262 | "outputs": [ 263 | { 264 | "data": { 265 | "text/plain": [ 266 | "0 424\n", 267 | "1 288\n", 268 | "Name: Survived, dtype: int64" 269 | ] 270 | }, 271 | "execution_count": 8, 272 | "metadata": {}, 273 | "output_type": "execute_result" 274 | } 275 | ], 276 | "source": [ 277 | "df['Survived'].value_counts()" 278 | ] 279 | }, 280 | { 281 | "cell_type": "code", 282 | "execution_count": 9, 283 | "metadata": {}, 284 | "outputs": [ 285 | { 286 | "data": { 287 | "text/plain": [ 288 | "male 453\n", 289 | "female 259\n", 290 | "Name: Sex, dtype: int64" 291 | ] 292 | }, 293 | "execution_count": 9, 294 | "metadata": {}, 295 | "output_type": "execute_result" 296 | } 297 | ], 298 | "source": [ 299 | "df['Sex'].value_counts()" 300 | ] 301 | }, 302 | { 303 | "cell_type": "code", 304 | "execution_count": 10, 305 | "metadata": {}, 306 | "outputs": [ 307 | { 308 | "data": { 309 | "text/plain": [ 310 | "3 355\n", 311 | "1 184\n", 312 | "2 173\n", 313 | "Name: Pclass, dtype: int64" 314 | ] 315 | }, 316 | "execution_count": 10, 317 | "metadata": {}, 318 | "output_type": "execute_result" 319 | } 320 | ], 321 | "source": [ 322 | "df['Pclass'].value_counts()" 323 | ] 324 | }, 325 | { 326 | "cell_type": "code", 327 | "execution_count": 11, 328 | "metadata": {}, 329 | "outputs": [ 330 | { 331 | "data": { 332 | "text/plain": [ 333 | "29.64209269662921" 334 | ] 335 | }, 336 | "execution_count": 11, 337 | "metadata": {}, 338 | "output_type": "execute_result" 339 | } 340 | ], 341 | "source": [ 342 | "df['Age'].mean()" 343 | ] 344 | }, 345 | { 346 | "cell_type": "code", 347 | "execution_count": 12, 348 | "metadata": {}, 349 | "outputs": [ 350 | { 351 | "data": { 352 | "text/plain": [ 353 | "Southampton 554\n", 354 | "Cherbourg 130\n", 355 | "Queenstown 28\n", 356 | "Name: Embarked, dtype: int64" 357 | ] 358 | }, 359 | "execution_count": 12, 360 | "metadata": {}, 361 | "output_type": "execute_result" 362 | } 363 | ], 364 | "source": [ 365 | "df['Embarked'].value_counts()\n", 366 | "# (C = Cherbourg; Q = Queenstown; S = Southampton)" 367 | ] 368 | }, 369 | { 370 | "cell_type": "markdown", 371 | "metadata": {}, 372 | "source": [ 373 | "## Visualizations" 374 | ] 375 | }, 376 | { 377 | "cell_type": "code", 378 | "execution_count": 13, 379 | "metadata": {}, 380 | "outputs": [ 381 | { 382 | "data": { 383 | "image/png": "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\n", 384 | "text/plain": [ 385 | "" 386 | ] 387 | }, 388 | "metadata": {}, 389 | "output_type": "display_data" 390 | } 391 | ], 392 | "source": [ 393 | "sns.barplot(x='Pclass', y='Fare', data=df);" 394 | ] 395 | }, 396 | { 397 | "cell_type": "code", 398 | "execution_count": 14, 399 | "metadata": {}, 400 | "outputs": [ 401 | { 402 | "data": { 403 | "image/png": "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\n", 404 | "text/plain": [ 405 | "" 406 | ] 407 | }, 408 | "metadata": {}, 409 | "output_type": "display_data" 410 | } 411 | ], 412 | "source": [ 413 | "# histogram\n", 414 | "sns.distplot(df['Age']);" 415 | ] 416 | }, 417 | { 418 | "cell_type": "code", 419 | "execution_count": 15, 420 | "metadata": {}, 421 | "outputs": [ 422 | { 423 | "data": { 424 | "image/png": "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\n", 425 | "text/plain": [ 426 | "" 427 | ] 428 | }, 429 | "metadata": {}, 430 | "output_type": "display_data" 431 | } 432 | ], 433 | "source": [ 434 | "# Comparison barchart\n", 435 | "sns.barplot(x=\"Sex\", y=\"Survived\", hue=\"Pclass\", data=df);" 436 | ] 437 | }, 438 | { 439 | "cell_type": "code", 440 | "execution_count": 16, 441 | "metadata": {}, 442 | "outputs": [ 443 | { 444 | "data": { 445 | "text/plain": [ 446 | "" 447 | ] 448 | }, 449 | "execution_count": 16, 450 | "metadata": {}, 451 | "output_type": "execute_result" 452 | }, 453 | { 454 | "data": { 455 | "image/png": "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\n", 456 | "text/plain": [ 457 | "" 458 | ] 459 | }, 460 | "metadata": {}, 461 | "output_type": "display_data" 462 | } 463 | ], 464 | "source": [ 465 | "# scatter \n", 466 | "sns.regplot(x='Age', y='Fare', data=df.loc[(df['Pclass']==3) & \n", 467 | " (df['Sex']=='male')], fit_reg=True)" 468 | ] 469 | }, 470 | { 471 | "cell_type": "code", 472 | "execution_count": 17, 473 | "metadata": {}, 474 | "outputs": [ 475 | { 476 | "data": { 477 | "text/plain": [ 478 | "[96.3855421686747,\n", 479 | " 91.8918918918919,\n", 480 | " 46.07843137254902,\n", 481 | " 39.603960396039604,\n", 482 | " 15.151515151515152,\n", 483 | " 15.019762845849801]" 484 | ] 485 | }, 486 | "execution_count": 17, 487 | "metadata": {}, 488 | "output_type": "execute_result" 489 | } 490 | ], 491 | "source": [ 492 | "sex_survive=df.groupby(['Sex', 'Pclass']).Survived.mean()\n", 493 | "sex_survive=sex_survive*100\n", 494 | "my_list=list(sex_survive)\n", 495 | "my_list" 496 | ] 497 | }, 498 | { 499 | "cell_type": "code", 500 | "execution_count": 18, 501 | "metadata": {}, 502 | "outputs": [], 503 | "source": [ 504 | "# Convert to csv\n", 505 | "df.to_csv('titanic.csv')" 506 | ] 507 | }, 508 | { 509 | "cell_type": "code", 510 | "execution_count": null, 511 | "metadata": {}, 512 | "outputs": [], 513 | "source": [] 514 | }, 515 | { 516 | "cell_type": "code", 517 | "execution_count": null, 518 | "metadata": {}, 519 | "outputs": [], 520 | "source": [] 521 | }, 522 | { 523 | "cell_type": "code", 524 | "execution_count": null, 525 | "metadata": {}, 526 | "outputs": [], 527 | "source": [] 528 | }, 529 | { 530 | "cell_type": "code", 531 | "execution_count": null, 532 | "metadata": {}, 533 | "outputs": [], 534 | "source": [] 535 | } 536 | ], 537 | "metadata": { 538 | "kernelspec": { 539 | "display_name": "Python 3", 540 | "language": "python", 541 | "name": "python3" 542 | }, 543 | "language_info": { 544 | "codemirror_mode": { 545 | "name": "ipython", 546 | "version": 3 547 | }, 548 | "file_extension": ".py", 549 | "mimetype": "text/x-python", 550 | "name": "python", 551 | "nbconvert_exporter": "python", 552 | "pygments_lexer": "ipython3", 553 | "version": "3.6.4" 554 | } 555 | }, 556 | "nbformat": 4, 557 | "nbformat_minor": 2 558 | } 559 | -------------------------------------------------------------------------------- /00 resources/requirements.txt: -------------------------------------------------------------------------------- 1 | 2 | dash==0.28.5 3 | dash-core-components==0.36.1 4 | dash-html-components==0.13.2 5 | dash-renderer==0.14.3 6 | dash-table==3.1.3 7 | -------------------------------------------------------------------------------- /00 resources/titanic.csv: -------------------------------------------------------------------------------- 1 | ,Survived,Pclass,Sex,Age,Fare,Embarked 2 | 0,0,3,male,22.0,7.25,Southampton 3 | 1,1,1,female,38.0,71.2833,Cherbourg 4 | 2,1,3,female,26.0,7.925,Southampton 5 | 3,1,1,female,35.0,53.1,Southampton 6 | 4,0,3,male,35.0,8.05,Southampton 7 | 6,0,1,male,54.0,51.8625,Southampton 8 | 7,0,3,male,2.0,21.075,Southampton 9 | 8,1,3,female,27.0,11.1333,Southampton 10 | 9,1,2,female,14.0,30.0708,Cherbourg 11 | 10,1,3,female,4.0,16.7,Southampton 12 | 11,1,1,female,58.0,26.55,Southampton 13 | 12,0,3,male,20.0,8.05,Southampton 14 | 13,0,3,male,39.0,31.275,Southampton 15 | 14,0,3,female,14.0,7.8542,Southampton 16 | 15,1,2,female,55.0,16.0,Southampton 17 | 16,0,3,male,2.0,29.125,Queenstown 18 | 18,0,3,female,31.0,18.0,Southampton 19 | 20,0,2,male,35.0,26.0,Southampton 20 | 21,1,2,male,34.0,13.0,Southampton 21 | 22,1,3,female,15.0,8.0292,Queenstown 22 | 23,1,1,male,28.0,35.5,Southampton 23 | 24,0,3,female,8.0,21.075,Southampton 24 | 25,1,3,female,38.0,31.3875,Southampton 25 | 27,0,1,male,19.0,263.0,Southampton 26 | 30,0,1,male,40.0,27.7208,Cherbourg 27 | 33,0,2,male,66.0,10.5,Southampton 28 | 34,0,1,male,28.0,82.1708,Cherbourg 29 | 35,0,1,male,42.0,52.0,Southampton 30 | 37,0,3,male,21.0,8.05,Southampton 31 | 38,0,3,female,18.0,18.0,Southampton 32 | 39,1,3,female,14.0,11.2417,Cherbourg 33 | 40,0,3,female,40.0,9.475,Southampton 34 | 41,0,2,female,27.0,21.0,Southampton 35 | 43,1,2,female,3.0,41.5792,Cherbourg 36 | 44,1,3,female,19.0,7.8792,Queenstown 37 | 49,0,3,female,18.0,17.8,Southampton 38 | 50,0,3,male,7.0,39.6875,Southampton 39 | 51,0,3,male,21.0,7.8,Southampton 40 | 52,1,1,female,49.0,76.7292,Cherbourg 41 | 53,1,2,female,29.0,26.0,Southampton 42 | 54,0,1,male,65.0,61.9792,Cherbourg 43 | 56,1,2,female,21.0,10.5,Southampton 44 | 57,0,3,male,28.5,7.2292,Cherbourg 45 | 58,1,2,female,5.0,27.75,Southampton 46 | 59,0,3,male,11.0,46.9,Southampton 47 | 60,0,3,male,22.0,7.2292,Cherbourg 48 | 62,0,1,male,45.0,83.475,Southampton 49 | 63,0,3,male,4.0,27.9,Southampton 50 | 66,1,2,female,29.0,10.5,Southampton 51 | 67,0,3,male,19.0,8.1583,Southampton 52 | 68,1,3,female,17.0,7.925,Southampton 53 | 69,0,3,male,26.0,8.6625,Southampton 54 | 70,0,2,male,32.0,10.5,Southampton 55 | 71,0,3,female,16.0,46.9,Southampton 56 | 72,0,2,male,21.0,73.5,Southampton 57 | 73,0,3,male,26.0,14.4542,Cherbourg 58 | 74,1,3,male,32.0,56.4958,Southampton 59 | 75,0,3,male,25.0,7.65,Southampton 60 | 78,1,2,male,0.83,29.0,Southampton 61 | 79,1,3,female,30.0,12.475,Southampton 62 | 80,0,3,male,22.0,9.0,Southampton 63 | 81,1,3,male,29.0,9.5,Southampton 64 | 83,0,1,male,28.0,47.1,Southampton 65 | 84,1,2,female,17.0,10.5,Southampton 66 | 85,1,3,female,33.0,15.85,Southampton 67 | 86,0,3,male,16.0,34.375,Southampton 68 | 88,1,1,female,23.0,263.0,Southampton 69 | 89,0,3,male,24.0,8.05,Southampton 70 | 90,0,3,male,29.0,8.05,Southampton 71 | 91,0,3,male,20.0,7.8542,Southampton 72 | 92,0,1,male,46.0,61.175,Southampton 73 | 93,0,3,male,26.0,20.575,Southampton 74 | 94,0,3,male,59.0,7.25,Southampton 75 | 96,0,1,male,71.0,34.6542,Cherbourg 76 | 97,1,1,male,23.0,63.3583,Cherbourg 77 | 98,1,2,female,34.0,23.0,Southampton 78 | 99,0,2,male,34.0,26.0,Southampton 79 | 100,0,3,female,28.0,7.8958,Southampton 80 | 102,0,1,male,21.0,77.2875,Southampton 81 | 103,0,3,male,33.0,8.6542,Southampton 82 | 104,0,3,male,37.0,7.925,Southampton 83 | 105,0,3,male,28.0,7.8958,Southampton 84 | 106,1,3,female,21.0,7.65,Southampton 85 | 108,0,3,male,38.0,7.8958,Southampton 86 | 110,0,1,male,47.0,52.0,Southampton 87 | 111,0,3,female,14.5,14.4542,Cherbourg 88 | 112,0,3,male,22.0,8.05,Southampton 89 | 113,0,3,female,20.0,9.825,Southampton 90 | 114,0,3,female,17.0,14.4583,Cherbourg 91 | 115,0,3,male,21.0,7.925,Southampton 92 | 116,0,3,male,70.5,7.75,Queenstown 93 | 117,0,2,male,29.0,21.0,Southampton 94 | 118,0,1,male,24.0,247.5208,Cherbourg 95 | 119,0,3,female,2.0,31.275,Southampton 96 | 120,0,2,male,21.0,73.5,Southampton 97 | 122,0,2,male,32.5,30.0708,Cherbourg 98 | 123,1,2,female,32.5,13.0,Southampton 99 | 124,0,1,male,54.0,77.2875,Southampton 100 | 125,1,3,male,12.0,11.2417,Cherbourg 101 | 127,1,3,male,24.0,7.1417,Southampton 102 | 129,0,3,male,45.0,6.975,Southampton 103 | 130,0,3,male,33.0,7.8958,Cherbourg 104 | 131,0,3,male,20.0,7.05,Southampton 105 | 132,0,3,female,47.0,14.5,Southampton 106 | 133,1,2,female,29.0,26.0,Southampton 107 | 134,0,2,male,25.0,13.0,Southampton 108 | 135,0,2,male,23.0,15.0458,Cherbourg 109 | 136,1,1,female,19.0,26.2833,Southampton 110 | 137,0,1,male,37.0,53.1,Southampton 111 | 138,0,3,male,16.0,9.2167,Southampton 112 | 139,0,1,male,24.0,79.2,Cherbourg 113 | 141,1,3,female,22.0,7.75,Southampton 114 | 142,1,3,female,24.0,15.85,Southampton 115 | 143,0,3,male,19.0,6.75,Queenstown 116 | 144,0,2,male,18.0,11.5,Southampton 117 | 145,0,2,male,19.0,36.75,Southampton 118 | 146,1,3,male,27.0,7.7958,Southampton 119 | 147,0,3,female,9.0,34.375,Southampton 120 | 148,0,2,male,36.5,26.0,Southampton 121 | 149,0,2,male,42.0,13.0,Southampton 122 | 150,0,2,male,51.0,12.525,Southampton 123 | 151,1,1,female,22.0,66.6,Southampton 124 | 152,0,3,male,55.5,8.05,Southampton 125 | 153,0,3,male,40.5,14.5,Southampton 126 | 155,0,1,male,51.0,61.3792,Cherbourg 127 | 156,1,3,female,16.0,7.7333,Queenstown 128 | 157,0,3,male,30.0,8.05,Southampton 129 | 160,0,3,male,44.0,16.1,Southampton 130 | 161,1,2,female,40.0,15.75,Southampton 131 | 162,0,3,male,26.0,7.775,Southampton 132 | 163,0,3,male,17.0,8.6625,Southampton 133 | 164,0,3,male,1.0,39.6875,Southampton 134 | 165,1,3,male,9.0,20.525,Southampton 135 | 167,0,3,female,45.0,27.9,Southampton 136 | 169,0,3,male,28.0,56.4958,Southampton 137 | 170,0,1,male,61.0,33.5,Southampton 138 | 171,0,3,male,4.0,29.125,Queenstown 139 | 172,1,3,female,1.0,11.1333,Southampton 140 | 173,0,3,male,21.0,7.925,Southampton 141 | 174,0,1,male,56.0,30.6958,Cherbourg 142 | 175,0,3,male,18.0,7.8542,Southampton 143 | 177,0,1,female,50.0,28.7125,Cherbourg 144 | 178,0,2,male,30.0,13.0,Southampton 145 | 179,0,3,male,36.0,0.0,Southampton 146 | 182,0,3,male,9.0,31.3875,Southampton 147 | 183,1,2,male,1.0,39.0,Southampton 148 | 184,1,3,female,4.0,22.025,Southampton 149 | 187,1,1,male,45.0,26.55,Southampton 150 | 188,0,3,male,40.0,15.5,Queenstown 151 | 189,0,3,male,36.0,7.8958,Southampton 152 | 190,1,2,female,32.0,13.0,Southampton 153 | 191,0,2,male,19.0,13.0,Southampton 154 | 192,1,3,female,19.0,7.8542,Southampton 155 | 193,1,2,male,3.0,26.0,Southampton 156 | 194,1,1,female,44.0,27.7208,Cherbourg 157 | 195,1,1,female,58.0,146.5208,Cherbourg 158 | 197,0,3,male,42.0,8.4042,Southampton 159 | 199,0,2,female,24.0,13.0,Southampton 160 | 200,0,3,male,28.0,9.5,Southampton 161 | 202,0,3,male,34.0,6.4958,Southampton 162 | 203,0,3,male,45.5,7.225,Cherbourg 163 | 204,1,3,male,18.0,8.05,Southampton 164 | 205,0,3,female,2.0,10.4625,Southampton 165 | 206,0,3,male,32.0,15.85,Southampton 166 | 207,1,3,male,26.0,18.7875,Cherbourg 167 | 208,1,3,female,16.0,7.75,Queenstown 168 | 209,1,1,male,40.0,31.0,Cherbourg 169 | 210,0,3,male,24.0,7.05,Southampton 170 | 211,1,2,female,35.0,21.0,Southampton 171 | 212,0,3,male,22.0,7.25,Southampton 172 | 213,0,2,male,30.0,13.0,Southampton 173 | 215,1,1,female,31.0,113.275,Cherbourg 174 | 216,1,3,female,27.0,7.925,Southampton 175 | 217,0,2,male,42.0,27.0,Southampton 176 | 218,1,1,female,32.0,76.2917,Cherbourg 177 | 219,0,2,male,30.0,10.5,Southampton 178 | 220,1,3,male,16.0,8.05,Southampton 179 | 221,0,2,male,27.0,13.0,Southampton 180 | 222,0,3,male,51.0,8.05,Southampton 181 | 224,1,1,male,38.0,90.0,Southampton 182 | 225,0,3,male,22.0,9.35,Southampton 183 | 226,1,2,male,19.0,10.5,Southampton 184 | 227,0,3,male,20.5,7.25,Southampton 185 | 228,0,2,male,18.0,13.0,Southampton 186 | 230,1,1,female,35.0,83.475,Southampton 187 | 231,0,3,male,29.0,7.775,Southampton 188 | 232,0,2,male,59.0,13.5,Southampton 189 | 233,1,3,female,5.0,31.3875,Southampton 190 | 234,0,2,male,24.0,10.5,Southampton 191 | 236,0,2,male,44.0,26.0,Southampton 192 | 237,1,2,female,8.0,26.25,Southampton 193 | 238,0,2,male,19.0,10.5,Southampton 194 | 239,0,2,male,33.0,12.275,Southampton 195 | 242,0,2,male,29.0,10.5,Southampton 196 | 243,0,3,male,22.0,7.125,Southampton 197 | 244,0,3,male,30.0,7.225,Cherbourg 198 | 245,0,1,male,44.0,90.0,Queenstown 199 | 246,0,3,female,25.0,7.775,Southampton 200 | 247,1,2,female,24.0,14.5,Southampton 201 | 248,1,1,male,37.0,52.5542,Southampton 202 | 249,0,2,male,54.0,26.0,Southampton 203 | 251,0,3,female,29.0,10.4625,Southampton 204 | 252,0,1,male,62.0,26.55,Southampton 205 | 253,0,3,male,30.0,16.1,Southampton 206 | 254,0,3,female,41.0,20.2125,Southampton 207 | 255,1,3,female,29.0,15.2458,Cherbourg 208 | 257,1,1,female,30.0,86.5,Southampton 209 | 258,1,1,female,35.0,512.3292,Cherbourg 210 | 259,1,2,female,50.0,26.0,Southampton 211 | 261,1,3,male,3.0,31.3875,Southampton 212 | 262,0,1,male,52.0,79.65,Southampton 213 | 263,0,1,male,40.0,0.0,Southampton 214 | 265,0,2,male,36.0,10.5,Southampton 215 | 266,0,3,male,16.0,39.6875,Southampton 216 | 267,1,3,male,25.0,7.775,Southampton 217 | 268,1,1,female,58.0,153.4625,Southampton 218 | 269,1,1,female,35.0,135.6333,Southampton 219 | 271,1,3,male,25.0,0.0,Southampton 220 | 272,1,2,female,41.0,19.5,Southampton 221 | 273,0,1,male,37.0,29.7,Cherbourg 222 | 275,1,1,female,63.0,77.9583,Southampton 223 | 276,0,3,female,45.0,7.75,Southampton 224 | 278,0,3,male,7.0,29.125,Queenstown 225 | 279,1,3,female,35.0,20.25,Southampton 226 | 280,0,3,male,65.0,7.75,Queenstown 227 | 281,0,3,male,28.0,7.8542,Southampton 228 | 282,0,3,male,16.0,9.5,Southampton 229 | 283,1,3,male,19.0,8.05,Southampton 230 | 285,0,3,male,33.0,8.6625,Cherbourg 231 | 286,1,3,male,30.0,9.5,Southampton 232 | 287,0,3,male,22.0,7.8958,Southampton 233 | 288,1,2,male,42.0,13.0,Southampton 234 | 289,1,3,female,22.0,7.75,Queenstown 235 | 290,1,1,female,26.0,78.85,Southampton 236 | 291,1,1,female,19.0,91.0792,Cherbourg 237 | 292,0,2,male,36.0,12.875,Cherbourg 238 | 293,0,3,female,24.0,8.85,Southampton 239 | 294,0,3,male,24.0,7.8958,Southampton 240 | 296,0,3,male,23.5,7.2292,Cherbourg 241 | 297,0,1,female,2.0,151.55,Southampton 242 | 299,1,1,female,50.0,247.5208,Cherbourg 243 | 302,0,3,male,19.0,0.0,Southampton 244 | 305,1,1,male,0.92,151.55,Southampton 245 | 307,1,1,female,17.0,108.9,Cherbourg 246 | 308,0,2,male,30.0,24.0,Cherbourg 247 | 309,1,1,female,30.0,56.9292,Cherbourg 248 | 310,1,1,female,24.0,83.1583,Cherbourg 249 | 311,1,1,female,18.0,262.375,Cherbourg 250 | 312,0,2,female,26.0,26.0,Southampton 251 | 313,0,3,male,28.0,7.8958,Southampton 252 | 314,0,2,male,43.0,26.25,Southampton 253 | 315,1,3,female,26.0,7.8542,Southampton 254 | 316,1,2,female,24.0,26.0,Southampton 255 | 317,0,2,male,54.0,14.0,Southampton 256 | 318,1,1,female,31.0,164.8667,Southampton 257 | 319,1,1,female,40.0,134.5,Cherbourg 258 | 320,0,3,male,22.0,7.25,Southampton 259 | 321,0,3,male,27.0,7.8958,Southampton 260 | 322,1,2,female,30.0,12.35,Queenstown 261 | 323,1,2,female,22.0,29.0,Southampton 262 | 325,1,1,female,36.0,135.6333,Cherbourg 263 | 326,0,3,male,61.0,6.2375,Southampton 264 | 327,1,2,female,36.0,13.0,Southampton 265 | 328,1,3,female,31.0,20.525,Southampton 266 | 329,1,1,female,16.0,57.9792,Cherbourg 267 | 331,0,1,male,45.5,28.5,Southampton 268 | 332,0,1,male,38.0,153.4625,Southampton 269 | 333,0,3,male,16.0,18.0,Southampton 270 | 336,0,1,male,29.0,66.6,Southampton 271 | 337,1,1,female,41.0,134.5,Cherbourg 272 | 338,1,3,male,45.0,8.05,Southampton 273 | 339,0,1,male,45.0,35.5,Southampton 274 | 340,1,2,male,2.0,26.0,Southampton 275 | 341,1,1,female,24.0,263.0,Southampton 276 | 342,0,2,male,28.0,13.0,Southampton 277 | 343,0,2,male,25.0,13.0,Southampton 278 | 344,0,2,male,36.0,13.0,Southampton 279 | 345,1,2,female,24.0,13.0,Southampton 280 | 346,1,2,female,40.0,13.0,Southampton 281 | 348,1,3,male,3.0,15.9,Southampton 282 | 349,0,3,male,42.0,8.6625,Southampton 283 | 350,0,3,male,23.0,9.225,Southampton 284 | 352,0,3,male,15.0,7.2292,Cherbourg 285 | 353,0,3,male,25.0,17.8,Southampton 286 | 355,0,3,male,28.0,9.5,Southampton 287 | 356,1,1,female,22.0,55.0,Southampton 288 | 357,0,2,female,38.0,13.0,Southampton 289 | 360,0,3,male,40.0,27.9,Southampton 290 | 361,0,2,male,29.0,27.7208,Cherbourg 291 | 362,0,3,female,45.0,14.4542,Cherbourg 292 | 363,0,3,male,35.0,7.05,Southampton 293 | 365,0,3,male,30.0,7.25,Southampton 294 | 366,1,1,female,60.0,75.25,Cherbourg 295 | 369,1,1,female,24.0,69.3,Cherbourg 296 | 370,1,1,male,25.0,55.4417,Cherbourg 297 | 371,0,3,male,18.0,6.4958,Southampton 298 | 372,0,3,male,19.0,8.05,Southampton 299 | 373,0,1,male,22.0,135.6333,Cherbourg 300 | 374,0,3,female,3.0,21.075,Southampton 301 | 376,1,3,female,22.0,7.25,Southampton 302 | 377,0,1,male,27.0,211.5,Cherbourg 303 | 378,0,3,male,20.0,4.0125,Cherbourg 304 | 379,0,3,male,19.0,7.775,Southampton 305 | 380,1,1,female,42.0,227.525,Cherbourg 306 | 381,1,3,female,1.0,15.7417,Cherbourg 307 | 382,0,3,male,32.0,7.925,Southampton 308 | 383,1,1,female,35.0,52.0,Southampton 309 | 385,0,2,male,18.0,73.5,Southampton 310 | 386,0,3,male,1.0,46.9,Southampton 311 | 387,1,2,female,36.0,13.0,Southampton 312 | 389,1,2,female,17.0,12.0,Cherbourg 313 | 390,1,1,male,36.0,120.0,Southampton 314 | 391,1,3,male,21.0,7.7958,Southampton 315 | 392,0,3,male,28.0,7.925,Southampton 316 | 393,1,1,female,23.0,113.275,Cherbourg 317 | 394,1,3,female,24.0,16.7,Southampton 318 | 395,0,3,male,22.0,7.7958,Southampton 319 | 396,0,3,female,31.0,7.8542,Southampton 320 | 397,0,2,male,46.0,26.0,Southampton 321 | 398,0,2,male,23.0,10.5,Southampton 322 | 399,1,2,female,28.0,12.65,Southampton 323 | 400,1,3,male,39.0,7.925,Southampton 324 | 401,0,3,male,26.0,8.05,Southampton 325 | 402,0,3,female,21.0,9.825,Southampton 326 | 403,0,3,male,28.0,15.85,Southampton 327 | 404,0,3,female,20.0,8.6625,Southampton 328 | 405,0,2,male,34.0,21.0,Southampton 329 | 406,0,3,male,51.0,7.75,Southampton 330 | 407,1,2,male,3.0,18.75,Southampton 331 | 408,0,3,male,21.0,7.775,Southampton 332 | 412,1,1,female,33.0,90.0,Queenstown 333 | 414,1,3,male,44.0,7.925,Southampton 334 | 416,1,2,female,34.0,32.5,Southampton 335 | 417,1,2,female,18.0,13.0,Southampton 336 | 418,0,2,male,30.0,13.0,Southampton 337 | 419,0,3,female,10.0,24.15,Southampton 338 | 421,0,3,male,21.0,7.7333,Queenstown 339 | 422,0,3,male,29.0,7.875,Southampton 340 | 423,0,3,female,28.0,14.4,Southampton 341 | 424,0,3,male,18.0,20.2125,Southampton 342 | 426,1,2,female,28.0,26.0,Southampton 343 | 427,1,2,female,19.0,26.0,Southampton 344 | 429,1,3,male,32.0,8.05,Southampton 345 | 430,1,1,male,28.0,26.55,Southampton 346 | 432,1,2,female,42.0,26.0,Southampton 347 | 433,0,3,male,17.0,7.125,Southampton 348 | 434,0,1,male,50.0,55.9,Southampton 349 | 435,1,1,female,14.0,120.0,Southampton 350 | 436,0,3,female,21.0,34.375,Southampton 351 | 437,1,2,female,24.0,18.75,Southampton 352 | 438,0,1,male,64.0,263.0,Southampton 353 | 439,0,2,male,31.0,10.5,Southampton 354 | 440,1,2,female,45.0,26.25,Southampton 355 | 441,0,3,male,20.0,9.5,Southampton 356 | 442,0,3,male,25.0,7.775,Southampton 357 | 443,1,2,female,28.0,13.0,Southampton 358 | 445,1,1,male,4.0,81.8583,Southampton 359 | 446,1,2,female,13.0,19.5,Southampton 360 | 447,1,1,male,34.0,26.55,Southampton 361 | 448,1,3,female,5.0,19.2583,Cherbourg 362 | 449,1,1,male,52.0,30.5,Southampton 363 | 450,0,2,male,36.0,27.75,Southampton 364 | 452,0,1,male,30.0,27.75,Cherbourg 365 | 453,1,1,male,49.0,89.1042,Cherbourg 366 | 455,1,3,male,29.0,7.8958,Cherbourg 367 | 456,0,1,male,65.0,26.55,Southampton 368 | 458,1,2,female,50.0,10.5,Southampton 369 | 460,1,1,male,48.0,26.55,Southampton 370 | 461,0,3,male,34.0,8.05,Southampton 371 | 462,0,1,male,47.0,38.5,Southampton 372 | 463,0,2,male,48.0,13.0,Southampton 373 | 465,0,3,male,38.0,7.05,Southampton 374 | 467,0,1,male,56.0,26.55,Southampton 375 | 469,1,3,female,0.75,19.2583,Cherbourg 376 | 471,0,3,male,38.0,8.6625,Southampton 377 | 472,1,2,female,33.0,27.75,Southampton 378 | 473,1,2,female,23.0,13.7917,Cherbourg 379 | 474,0,3,female,22.0,9.8375,Southampton 380 | 476,0,2,male,34.0,21.0,Southampton 381 | 477,0,3,male,29.0,7.0458,Southampton 382 | 478,0,3,male,22.0,7.5208,Southampton 383 | 479,1,3,female,2.0,12.2875,Southampton 384 | 480,0,3,male,9.0,46.9,Southampton 385 | 482,0,3,male,50.0,8.05,Southampton 386 | 483,1,3,female,63.0,9.5875,Southampton 387 | 484,1,1,male,25.0,91.0792,Cherbourg 388 | 486,1,1,female,35.0,90.0,Southampton 389 | 487,0,1,male,58.0,29.7,Cherbourg 390 | 488,0,3,male,30.0,8.05,Southampton 391 | 489,1,3,male,9.0,15.9,Southampton 392 | 491,0,3,male,21.0,7.25,Southampton 393 | 492,0,1,male,55.0,30.5,Southampton 394 | 493,0,1,male,71.0,49.5042,Cherbourg 395 | 494,0,3,male,21.0,8.05,Southampton 396 | 496,1,1,female,54.0,78.2667,Cherbourg 397 | 498,0,1,female,25.0,151.55,Southampton 398 | 499,0,3,male,24.0,7.7958,Southampton 399 | 500,0,3,male,17.0,8.6625,Southampton 400 | 501,0,3,female,21.0,7.75,Queenstown 401 | 503,0,3,female,37.0,9.5875,Southampton 402 | 504,1,1,female,16.0,86.5,Southampton 403 | 505,0,1,male,18.0,108.9,Cherbourg 404 | 506,1,2,female,33.0,26.0,Southampton 405 | 508,0,3,male,28.0,22.525,Southampton 406 | 509,1,3,male,26.0,56.4958,Southampton 407 | 510,1,3,male,29.0,7.75,Queenstown 408 | 512,1,1,male,36.0,26.2875,Southampton 409 | 513,1,1,female,54.0,59.4,Cherbourg 410 | 514,0,3,male,24.0,7.4958,Southampton 411 | 515,0,1,male,47.0,34.0208,Southampton 412 | 516,1,2,female,34.0,10.5,Southampton 413 | 518,1,2,female,36.0,26.0,Southampton 414 | 519,0,3,male,32.0,7.8958,Southampton 415 | 520,1,1,female,30.0,93.5,Southampton 416 | 521,0,3,male,22.0,7.8958,Southampton 417 | 523,1,1,female,44.0,57.9792,Cherbourg 418 | 525,0,3,male,40.5,7.75,Queenstown 419 | 526,1,2,female,50.0,10.5,Southampton 420 | 528,0,3,male,39.0,7.925,Southampton 421 | 529,0,2,male,23.0,11.5,Southampton 422 | 530,1,2,female,2.0,26.0,Southampton 423 | 532,0,3,male,17.0,7.2292,Cherbourg 424 | 534,0,3,female,30.0,8.6625,Southampton 425 | 535,1,2,female,7.0,26.25,Southampton 426 | 536,0,1,male,45.0,26.55,Southampton 427 | 537,1,1,female,30.0,106.425,Cherbourg 428 | 539,1,1,female,22.0,49.5,Cherbourg 429 | 540,1,1,female,36.0,71.0,Southampton 430 | 541,0,3,female,9.0,31.275,Southampton 431 | 542,0,3,female,11.0,31.275,Southampton 432 | 543,1,2,male,32.0,26.0,Southampton 433 | 544,0,1,male,50.0,106.425,Cherbourg 434 | 545,0,1,male,64.0,26.0,Southampton 435 | 546,1,2,female,19.0,26.0,Southampton 436 | 548,0,3,male,33.0,20.525,Southampton 437 | 549,1,2,male,8.0,36.75,Southampton 438 | 550,1,1,male,17.0,110.8833,Cherbourg 439 | 551,0,2,male,27.0,26.0,Southampton 440 | 553,1,3,male,22.0,7.225,Cherbourg 441 | 554,1,3,female,22.0,7.775,Southampton 442 | 555,0,1,male,62.0,26.55,Southampton 443 | 556,1,1,female,48.0,39.6,Cherbourg 444 | 558,1,1,female,39.0,79.65,Southampton 445 | 559,1,3,female,36.0,17.4,Southampton 446 | 561,0,3,male,40.0,7.8958,Southampton 447 | 562,0,2,male,28.0,13.5,Southampton 448 | 565,0,3,male,24.0,24.15,Southampton 449 | 566,0,3,male,19.0,7.8958,Southampton 450 | 567,0,3,female,29.0,21.075,Southampton 451 | 569,1,3,male,32.0,7.8542,Southampton 452 | 570,1,2,male,62.0,10.5,Southampton 453 | 571,1,1,female,53.0,51.4792,Southampton 454 | 572,1,1,male,36.0,26.3875,Southampton 455 | 574,0,3,male,16.0,8.05,Southampton 456 | 575,0,3,male,19.0,14.5,Southampton 457 | 576,1,2,female,34.0,13.0,Southampton 458 | 577,1,1,female,39.0,55.9,Southampton 459 | 579,1,3,male,32.0,7.925,Southampton 460 | 580,1,2,female,25.0,30.0,Southampton 461 | 581,1,1,female,39.0,110.8833,Cherbourg 462 | 582,0,2,male,54.0,26.0,Southampton 463 | 583,0,1,male,36.0,40.125,Cherbourg 464 | 585,1,1,female,18.0,79.65,Southampton 465 | 586,0,2,male,47.0,15.0,Southampton 466 | 587,1,1,male,60.0,79.2,Cherbourg 467 | 588,0,3,male,22.0,8.05,Southampton 468 | 590,0,3,male,35.0,7.125,Southampton 469 | 591,1,1,female,52.0,78.2667,Cherbourg 470 | 592,0,3,male,47.0,7.25,Southampton 471 | 594,0,2,male,37.0,26.0,Southampton 472 | 595,0,3,male,36.0,24.15,Southampton 473 | 597,0,3,male,49.0,0.0,Southampton 474 | 599,1,1,male,49.0,56.9292,Cherbourg 475 | 600,1,2,female,24.0,27.0,Southampton 476 | 603,0,3,male,44.0,8.05,Southampton 477 | 604,1,1,male,35.0,26.55,Cherbourg 478 | 605,0,3,male,36.0,15.55,Southampton 479 | 606,0,3,male,30.0,7.8958,Southampton 480 | 607,1,1,male,27.0,30.5,Southampton 481 | 608,1,2,female,22.0,41.5792,Cherbourg 482 | 609,1,1,female,40.0,153.4625,Southampton 483 | 610,0,3,female,39.0,31.275,Southampton 484 | 614,0,3,male,35.0,8.05,Southampton 485 | 615,1,2,female,24.0,65.0,Southampton 486 | 616,0,3,male,34.0,14.4,Southampton 487 | 617,0,3,female,26.0,16.1,Southampton 488 | 618,1,2,female,4.0,39.0,Southampton 489 | 619,0,2,male,26.0,10.5,Southampton 490 | 620,0,3,male,27.0,14.4542,Cherbourg 491 | 621,1,1,male,42.0,52.5542,Southampton 492 | 622,1,3,male,20.0,15.7417,Cherbourg 493 | 623,0,3,male,21.0,7.8542,Southampton 494 | 624,0,3,male,21.0,16.1,Southampton 495 | 625,0,1,male,61.0,32.3208,Southampton 496 | 626,0,2,male,57.0,12.35,Queenstown 497 | 627,1,1,female,21.0,77.9583,Southampton 498 | 628,0,3,male,26.0,7.8958,Southampton 499 | 630,1,1,male,80.0,30.0,Southampton 500 | 631,0,3,male,51.0,7.0542,Southampton 501 | 632,1,1,male,32.0,30.5,Cherbourg 502 | 634,0,3,female,9.0,27.9,Southampton 503 | 635,1,2,female,28.0,13.0,Southampton 504 | 636,0,3,male,32.0,7.925,Southampton 505 | 637,0,2,male,31.0,26.25,Southampton 506 | 638,0,3,female,41.0,39.6875,Southampton 507 | 640,0,3,male,20.0,7.8542,Southampton 508 | 641,1,1,female,24.0,69.3,Cherbourg 509 | 642,0,3,female,2.0,27.9,Southampton 510 | 644,1,3,female,0.75,19.2583,Cherbourg 511 | 645,1,1,male,48.0,76.7292,Cherbourg 512 | 646,0,3,male,19.0,7.8958,Southampton 513 | 647,1,1,male,56.0,35.5,Cherbourg 514 | 649,1,3,female,23.0,7.55,Southampton 515 | 651,1,2,female,18.0,23.0,Southampton 516 | 652,0,3,male,21.0,8.4333,Southampton 517 | 654,0,3,female,18.0,6.75,Queenstown 518 | 655,0,2,male,24.0,73.5,Southampton 519 | 657,0,3,female,32.0,15.5,Queenstown 520 | 658,0,2,male,23.0,13.0,Southampton 521 | 659,0,1,male,58.0,113.275,Cherbourg 522 | 660,1,1,male,50.0,133.65,Southampton 523 | 661,0,3,male,40.0,7.225,Cherbourg 524 | 662,0,1,male,47.0,25.5875,Southampton 525 | 663,0,3,male,36.0,7.4958,Southampton 526 | 664,1,3,male,20.0,7.925,Southampton 527 | 665,0,2,male,32.0,73.5,Southampton 528 | 666,0,2,male,25.0,13.0,Southampton 529 | 668,0,3,male,43.0,8.05,Southampton 530 | 670,1,2,female,40.0,39.0,Southampton 531 | 671,0,1,male,31.0,52.0,Southampton 532 | 672,0,2,male,70.0,10.5,Southampton 533 | 673,1,2,male,31.0,13.0,Southampton 534 | 675,0,3,male,18.0,7.775,Southampton 535 | 676,0,3,male,24.5,8.05,Southampton 536 | 677,1,3,female,18.0,9.8417,Southampton 537 | 678,0,3,female,43.0,46.9,Southampton 538 | 679,1,1,male,36.0,512.3292,Cherbourg 539 | 681,1,1,male,27.0,76.7292,Cherbourg 540 | 682,0,3,male,20.0,9.225,Southampton 541 | 683,0,3,male,14.0,46.9,Southampton 542 | 684,0,2,male,60.0,39.0,Southampton 543 | 685,0,2,male,25.0,41.5792,Cherbourg 544 | 686,0,3,male,14.0,39.6875,Southampton 545 | 687,0,3,male,19.0,10.1708,Southampton 546 | 688,0,3,male,18.0,7.7958,Southampton 547 | 689,1,1,female,15.0,211.3375,Southampton 548 | 690,1,1,male,31.0,57.0,Southampton 549 | 691,1,3,female,4.0,13.4167,Cherbourg 550 | 693,0,3,male,25.0,7.225,Cherbourg 551 | 694,0,1,male,60.0,26.55,Southampton 552 | 695,0,2,male,52.0,13.5,Southampton 553 | 696,0,3,male,44.0,8.05,Southampton 554 | 698,0,1,male,49.0,110.8833,Cherbourg 555 | 699,0,3,male,42.0,7.65,Southampton 556 | 700,1,1,female,18.0,227.525,Cherbourg 557 | 701,1,1,male,35.0,26.2875,Southampton 558 | 702,0,3,female,18.0,14.4542,Cherbourg 559 | 703,0,3,male,25.0,7.7417,Queenstown 560 | 704,0,3,male,26.0,7.8542,Southampton 561 | 705,0,2,male,39.0,26.0,Southampton 562 | 706,1,2,female,45.0,13.5,Southampton 563 | 707,1,1,male,42.0,26.2875,Southampton 564 | 708,1,1,female,22.0,151.55,Southampton 565 | 710,1,1,female,24.0,49.5042,Cherbourg 566 | 712,1,1,male,48.0,52.0,Southampton 567 | 713,0,3,male,29.0,9.4833,Southampton 568 | 714,0,2,male,52.0,13.0,Southampton 569 | 715,0,3,male,19.0,7.65,Southampton 570 | 716,1,1,female,38.0,227.525,Cherbourg 571 | 717,1,2,female,27.0,10.5,Southampton 572 | 719,0,3,male,33.0,7.775,Southampton 573 | 720,1,2,female,6.0,33.0,Southampton 574 | 721,0,3,male,17.0,7.0542,Southampton 575 | 722,0,2,male,34.0,13.0,Southampton 576 | 723,0,2,male,50.0,13.0,Southampton 577 | 724,1,1,male,27.0,53.1,Southampton 578 | 725,0,3,male,20.0,8.6625,Southampton 579 | 726,1,2,female,30.0,21.0,Southampton 580 | 728,0,2,male,25.0,26.0,Southampton 581 | 729,0,3,female,25.0,7.925,Southampton 582 | 730,1,1,female,29.0,211.3375,Southampton 583 | 731,0,3,male,11.0,18.7875,Cherbourg 584 | 733,0,2,male,23.0,13.0,Southampton 585 | 734,0,2,male,23.0,13.0,Southampton 586 | 735,0,3,male,28.5,16.1,Southampton 587 | 736,0,3,female,48.0,34.375,Southampton 588 | 737,1,1,male,35.0,512.3292,Cherbourg 589 | 741,0,1,male,36.0,78.85,Southampton 590 | 742,1,1,female,21.0,262.375,Cherbourg 591 | 743,0,3,male,24.0,16.1,Southampton 592 | 744,1,3,male,31.0,7.925,Southampton 593 | 745,0,1,male,70.0,71.0,Southampton 594 | 746,0,3,male,16.0,20.25,Southampton 595 | 747,1,2,female,30.0,13.0,Southampton 596 | 748,0,1,male,19.0,53.1,Southampton 597 | 749,0,3,male,31.0,7.75,Queenstown 598 | 750,1,2,female,4.0,23.0,Southampton 599 | 751,1,3,male,6.0,12.475,Southampton 600 | 752,0,3,male,33.0,9.5,Southampton 601 | 753,0,3,male,23.0,7.8958,Southampton 602 | 754,1,2,female,48.0,65.0,Southampton 603 | 755,1,2,male,0.67,14.5,Southampton 604 | 756,0,3,male,28.0,7.7958,Southampton 605 | 757,0,2,male,18.0,11.5,Southampton 606 | 758,0,3,male,34.0,8.05,Southampton 607 | 759,1,1,female,33.0,86.5,Southampton 608 | 761,0,3,male,41.0,7.125,Southampton 609 | 762,1,3,male,20.0,7.2292,Cherbourg 610 | 763,1,1,female,36.0,120.0,Southampton 611 | 764,0,3,male,16.0,7.775,Southampton 612 | 765,1,1,female,51.0,77.9583,Southampton 613 | 767,0,3,female,30.5,7.75,Queenstown 614 | 769,0,3,male,32.0,8.3625,Southampton 615 | 770,0,3,male,24.0,9.5,Southampton 616 | 771,0,3,male,48.0,7.8542,Southampton 617 | 772,0,2,female,57.0,10.5,Southampton 618 | 774,1,2,female,54.0,23.0,Southampton 619 | 775,0,3,male,18.0,7.75,Southampton 620 | 777,1,3,female,5.0,12.475,Southampton 621 | 779,1,1,female,43.0,211.3375,Southampton 622 | 780,1,3,female,13.0,7.2292,Cherbourg 623 | 781,1,1,female,17.0,57.0,Southampton 624 | 782,0,1,male,29.0,30.0,Southampton 625 | 784,0,3,male,25.0,7.05,Southampton 626 | 785,0,3,male,25.0,7.25,Southampton 627 | 786,1,3,female,18.0,7.4958,Southampton 628 | 787,0,3,male,8.0,29.125,Queenstown 629 | 788,1,3,male,1.0,20.575,Southampton 630 | 789,0,1,male,46.0,79.2,Cherbourg 631 | 791,0,2,male,16.0,26.0,Southampton 632 | 794,0,3,male,25.0,7.8958,Southampton 633 | 795,0,2,male,39.0,13.0,Southampton 634 | 796,1,1,female,49.0,25.9292,Southampton 635 | 797,1,3,female,31.0,8.6833,Southampton 636 | 798,0,3,male,30.0,7.2292,Cherbourg 637 | 799,0,3,female,30.0,24.15,Southampton 638 | 800,0,2,male,34.0,13.0,Southampton 639 | 801,1,2,female,31.0,26.25,Southampton 640 | 802,1,1,male,11.0,120.0,Southampton 641 | 803,1,3,male,0.42,8.5167,Cherbourg 642 | 804,1,3,male,27.0,6.975,Southampton 643 | 805,0,3,male,31.0,7.775,Southampton 644 | 806,0,1,male,39.0,0.0,Southampton 645 | 807,0,3,female,18.0,7.775,Southampton 646 | 808,0,2,male,39.0,13.0,Southampton 647 | 809,1,1,female,33.0,53.1,Southampton 648 | 810,0,3,male,26.0,7.8875,Southampton 649 | 811,0,3,male,39.0,24.15,Southampton 650 | 812,0,2,male,35.0,10.5,Southampton 651 | 813,0,3,female,6.0,31.275,Southampton 652 | 814,0,3,male,30.5,8.05,Southampton 653 | 816,0,3,female,23.0,7.925,Southampton 654 | 817,0,2,male,31.0,37.0042,Cherbourg 655 | 818,0,3,male,43.0,6.45,Southampton 656 | 819,0,3,male,10.0,27.9,Southampton 657 | 820,1,1,female,52.0,93.5,Southampton 658 | 821,1,3,male,27.0,8.6625,Southampton 659 | 822,0,1,male,38.0,0.0,Southampton 660 | 823,1,3,female,27.0,12.475,Southampton 661 | 824,0,3,male,2.0,39.6875,Southampton 662 | 827,1,2,male,1.0,37.0042,Cherbourg 663 | 830,1,3,female,15.0,14.4542,Cherbourg 664 | 831,1,2,male,0.83,18.75,Southampton 665 | 833,0,3,male,23.0,7.8542,Southampton 666 | 834,0,3,male,18.0,8.3,Southampton 667 | 835,1,1,female,39.0,83.1583,Cherbourg 668 | 836,0,3,male,21.0,8.6625,Southampton 669 | 838,1,3,male,32.0,56.4958,Southampton 670 | 840,0,3,male,20.0,7.925,Southampton 671 | 841,0,2,male,16.0,10.5,Southampton 672 | 842,1,1,female,30.0,31.0,Cherbourg 673 | 843,0,3,male,34.5,6.4375,Cherbourg 674 | 844,0,3,male,17.0,8.6625,Southampton 675 | 845,0,3,male,42.0,7.55,Southampton 676 | 847,0,3,male,35.0,7.8958,Cherbourg 677 | 848,0,2,male,28.0,33.0,Southampton 678 | 850,0,3,male,4.0,31.275,Southampton 679 | 851,0,3,male,74.0,7.775,Southampton 680 | 852,0,3,female,9.0,15.2458,Cherbourg 681 | 853,1,1,female,16.0,39.4,Southampton 682 | 854,0,2,female,44.0,26.0,Southampton 683 | 855,1,3,female,18.0,9.35,Southampton 684 | 856,1,1,female,45.0,164.8667,Southampton 685 | 857,1,1,male,51.0,26.55,Southampton 686 | 858,1,3,female,24.0,19.2583,Cherbourg 687 | 860,0,3,male,41.0,14.1083,Southampton 688 | 861,0,2,male,21.0,11.5,Southampton 689 | 862,1,1,female,48.0,25.9292,Southampton 690 | 864,0,2,male,24.0,13.0,Southampton 691 | 865,1,2,female,42.0,13.0,Southampton 692 | 866,1,2,female,27.0,13.8583,Cherbourg 693 | 867,0,1,male,31.0,50.4958,Southampton 694 | 869,1,3,male,4.0,11.1333,Southampton 695 | 870,0,3,male,26.0,7.8958,Southampton 696 | 871,1,1,female,47.0,52.5542,Southampton 697 | 872,0,1,male,33.0,5.0,Southampton 698 | 873,0,3,male,47.0,9.0,Southampton 699 | 874,1,2,female,28.0,24.0,Cherbourg 700 | 875,1,3,female,15.0,7.225,Cherbourg 701 | 876,0,3,male,20.0,9.8458,Southampton 702 | 877,0,3,male,19.0,7.8958,Southampton 703 | 879,1,1,female,56.0,83.1583,Cherbourg 704 | 880,1,2,female,25.0,26.0,Southampton 705 | 881,0,3,male,33.0,7.8958,Southampton 706 | 882,0,3,female,22.0,10.5167,Southampton 707 | 883,0,2,male,28.0,10.5,Southampton 708 | 884,0,3,male,25.0,7.05,Southampton 709 | 885,0,3,female,39.0,29.125,Queenstown 710 | 886,0,2,male,27.0,13.0,Southampton 711 | 887,1,1,female,19.0,30.0,Southampton 712 | 889,1,1,male,26.0,30.0,Cherbourg 713 | 890,0,3,male,32.0,7.75,Queenstown 714 | -------------------------------------------------------------------------------- /01 Plotly figures/Exploring the example dataset.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### A quick exploration of the example dataset" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "import numpy as np\n", 17 | "import pandas as pd\n", 18 | "import seaborn as sns\n", 19 | "import matplotlib.pyplot as plt\n", 20 | "%matplotlib inline" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 2, 26 | "metadata": {}, 27 | "outputs": [ 28 | { 29 | "data": { 30 | "text/plain": [ 31 | "(891, 12)" 32 | ] 33 | }, 34 | "execution_count": 2, 35 | "metadata": {}, 36 | "output_type": "execute_result" 37 | } 38 | ], 39 | "source": [ 40 | "# Read in the source data from Kaggle\n", 41 | "url=\"https://raw.githubusercontent.com/agconti/kaggle-titanic/master/data/train.csv\"\n", 42 | "df=pd.read_csv(url)\n", 43 | "df.shape" 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": 3, 49 | "metadata": {}, 50 | "outputs": [ 51 | { 52 | "data": { 53 | "text/plain": [ 54 | "(712, 6)" 55 | ] 56 | }, 57 | "execution_count": 3, 58 | "metadata": {}, 59 | "output_type": "execute_result" 60 | } 61 | ], 62 | "source": [ 63 | "# Keep only a few columns, and drop missing values\n", 64 | "df = df[['Survived', 'Pclass', 'Sex', 'Age', 'Fare', 'Embarked']]\n", 65 | "df.dropna(how='any', inplace=True);\n", 66 | "df.shape" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 4, 72 | "metadata": {}, 73 | "outputs": [ 74 | { 75 | "data": { 76 | "text/plain": [ 77 | "Southampton 554\n", 78 | "Cherbourg 130\n", 79 | "Queenstown 28\n", 80 | "Name: Embarked, dtype: int64" 81 | ] 82 | }, 83 | "execution_count": 4, 84 | "metadata": {}, 85 | "output_type": "execute_result" 86 | } 87 | ], 88 | "source": [ 89 | "# Let's spell out the port of embarcation\n", 90 | "df.loc[(df['Embarked']=='C') , 'Embarked']='Cherbourg'\n", 91 | "df.loc[(df['Embarked']=='Q') , 'Embarked']='Queenstown'\n", 92 | "df.loc[(df['Embarked']=='S') , 'Embarked']='Southampton'\n", 93 | "df['Embarked'].value_counts()" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": 5, 99 | "metadata": {}, 100 | "outputs": [ 101 | { 102 | "name": "stdout", 103 | "output_type": "stream", 104 | "text": [ 105 | "int64\n" 106 | ] 107 | }, 108 | { 109 | "data": { 110 | "text/plain": [ 111 | "1 184\n", 112 | "2 173\n", 113 | "3 355\n", 114 | "Name: Pclass, dtype: int64" 115 | ] 116 | }, 117 | "execution_count": 5, 118 | "metadata": {}, 119 | "output_type": "execute_result" 120 | } 121 | ], 122 | "source": [ 123 | "# Convert Pclass to a numeric format, and sort it\n", 124 | "df['Pclass'] = pd.to_numeric(df['Pclass'], errors='coerce').fillna(0).astype(np.int64);\n", 125 | "print(df['Pclass'].dtype)\n", 126 | "df['Pclass'].value_counts().sort_index()" 127 | ] 128 | }, 129 | { 130 | "cell_type": "markdown", 131 | "metadata": {}, 132 | "source": [ 133 | "## Basic value counts" 134 | ] 135 | }, 136 | { 137 | "cell_type": "code", 138 | "execution_count": 6, 139 | "metadata": {}, 140 | "outputs": [ 141 | { 142 | "data": { 143 | "text/html": [ 144 | "
\n", 145 | "\n", 158 | "\n", 159 | " \n", 160 | " \n", 161 | " \n", 162 | " \n", 163 | " \n", 164 | " \n", 165 | " \n", 166 | " \n", 167 | " \n", 168 | " \n", 169 | " \n", 170 | " \n", 171 | " \n", 172 | " \n", 173 | " \n", 174 | " \n", 175 | " \n", 176 | " \n", 177 | " \n", 178 | " \n", 179 | " \n", 180 | " \n", 181 | " \n", 182 | " \n", 183 | " \n", 184 | " \n", 185 | " \n", 186 | " \n", 187 | " \n", 188 | " \n", 189 | " \n", 190 | " \n", 191 | " \n", 192 | " \n", 193 | " \n", 194 | " \n", 195 | " \n", 196 | " \n", 197 | " \n", 198 | " \n", 199 | " \n", 200 | " \n", 201 | " \n", 202 | " \n", 203 | " \n", 204 | " \n", 205 | " \n", 206 | " \n", 207 | " \n", 208 | " \n", 209 | " \n", 210 | " \n", 211 | " \n", 212 | " \n", 213 | " \n", 214 | " \n", 215 | " \n", 216 | " \n", 217 | "
SurvivedPclassSexAgeFareEmbarked
003male22.07.2500Southampton
111female38.071.2833Cherbourg
213female26.07.9250Southampton
311female35.053.1000Southampton
403male35.08.0500Southampton
\n", 218 | "
" 219 | ], 220 | "text/plain": [ 221 | " Survived Pclass Sex Age Fare Embarked\n", 222 | "0 0 3 male 22.0 7.2500 Southampton\n", 223 | "1 1 1 female 38.0 71.2833 Cherbourg\n", 224 | "2 1 3 female 26.0 7.9250 Southampton\n", 225 | "3 1 1 female 35.0 53.1000 Southampton\n", 226 | "4 0 3 male 35.0 8.0500 Southampton" 227 | ] 228 | }, 229 | "execution_count": 6, 230 | "metadata": {}, 231 | "output_type": "execute_result" 232 | } 233 | ], 234 | "source": [ 235 | "df.head()" 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": 7, 241 | "metadata": {}, 242 | "outputs": [ 243 | { 244 | "data": { 245 | "text/plain": [ 246 | "Index(['Survived', 'Pclass', 'Sex', 'Age', 'Fare', 'Embarked'], dtype='object')" 247 | ] 248 | }, 249 | "execution_count": 7, 250 | "metadata": {}, 251 | "output_type": "execute_result" 252 | } 253 | ], 254 | "source": [ 255 | "df.columns" 256 | ] 257 | }, 258 | { 259 | "cell_type": "code", 260 | "execution_count": 8, 261 | "metadata": {}, 262 | "outputs": [ 263 | { 264 | "data": { 265 | "text/plain": [ 266 | "0 424\n", 267 | "1 288\n", 268 | "Name: Survived, dtype: int64" 269 | ] 270 | }, 271 | "execution_count": 8, 272 | "metadata": {}, 273 | "output_type": "execute_result" 274 | } 275 | ], 276 | "source": [ 277 | "df['Survived'].value_counts()" 278 | ] 279 | }, 280 | { 281 | "cell_type": "code", 282 | "execution_count": 9, 283 | "metadata": {}, 284 | "outputs": [ 285 | { 286 | "data": { 287 | "text/plain": [ 288 | "male 453\n", 289 | "female 259\n", 290 | "Name: Sex, dtype: int64" 291 | ] 292 | }, 293 | "execution_count": 9, 294 | "metadata": {}, 295 | "output_type": "execute_result" 296 | } 297 | ], 298 | "source": [ 299 | "df['Sex'].value_counts()" 300 | ] 301 | }, 302 | { 303 | "cell_type": "code", 304 | "execution_count": 10, 305 | "metadata": {}, 306 | "outputs": [ 307 | { 308 | "data": { 309 | "text/plain": [ 310 | "3 355\n", 311 | "1 184\n", 312 | "2 173\n", 313 | "Name: Pclass, dtype: int64" 314 | ] 315 | }, 316 | "execution_count": 10, 317 | "metadata": {}, 318 | "output_type": "execute_result" 319 | } 320 | ], 321 | "source": [ 322 | "df['Pclass'].value_counts()" 323 | ] 324 | }, 325 | { 326 | "cell_type": "code", 327 | "execution_count": 11, 328 | "metadata": {}, 329 | "outputs": [ 330 | { 331 | "data": { 332 | "text/plain": [ 333 | "29.64209269662921" 334 | ] 335 | }, 336 | "execution_count": 11, 337 | "metadata": {}, 338 | "output_type": "execute_result" 339 | } 340 | ], 341 | "source": [ 342 | "df['Age'].mean()" 343 | ] 344 | }, 345 | { 346 | "cell_type": "code", 347 | "execution_count": 12, 348 | "metadata": {}, 349 | "outputs": [ 350 | { 351 | "data": { 352 | "text/plain": [ 353 | "Southampton 554\n", 354 | "Cherbourg 130\n", 355 | "Queenstown 28\n", 356 | "Name: Embarked, dtype: int64" 357 | ] 358 | }, 359 | "execution_count": 12, 360 | "metadata": {}, 361 | "output_type": "execute_result" 362 | } 363 | ], 364 | "source": [ 365 | "df['Embarked'].value_counts()\n", 366 | "# (C = Cherbourg; Q = Queenstown; S = Southampton)" 367 | ] 368 | }, 369 | { 370 | "cell_type": "markdown", 371 | "metadata": {}, 372 | "source": [ 373 | "## Visualizations" 374 | ] 375 | }, 376 | { 377 | "cell_type": "code", 378 | "execution_count": 13, 379 | "metadata": {}, 380 | "outputs": [ 381 | { 382 | "data": { 383 | "image/png": "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\n", 384 | "text/plain": [ 385 | "" 386 | ] 387 | }, 388 | "metadata": { 389 | "needs_background": "light" 390 | }, 391 | "output_type": "display_data" 392 | } 393 | ], 394 | "source": [ 395 | "sns.barplot(x='Pclass', y='Fare', data=df);" 396 | ] 397 | }, 398 | { 399 | "cell_type": "code", 400 | "execution_count": 14, 401 | "metadata": {}, 402 | "outputs": [ 403 | { 404 | "data": { 405 | "image/png": "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\n", 406 | "text/plain": [ 407 | "" 408 | ] 409 | }, 410 | "metadata": { 411 | "needs_background": "light" 412 | }, 413 | "output_type": "display_data" 414 | } 415 | ], 416 | "source": [ 417 | "# histogram\n", 418 | "sns.distplot(df['Age']);" 419 | ] 420 | }, 421 | { 422 | "cell_type": "code", 423 | "execution_count": 15, 424 | "metadata": {}, 425 | "outputs": [ 426 | { 427 | "data": { 428 | "image/png": "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\n", 429 | "text/plain": [ 430 | "" 431 | ] 432 | }, 433 | "metadata": { 434 | "needs_background": "light" 435 | }, 436 | "output_type": "display_data" 437 | } 438 | ], 439 | "source": [ 440 | "# Comparison barchart\n", 441 | "sns.barplot(x=\"Sex\", y=\"Survived\", hue=\"Pclass\", data=df);" 442 | ] 443 | }, 444 | { 445 | "cell_type": "code", 446 | "execution_count": 16, 447 | "metadata": {}, 448 | "outputs": [ 449 | { 450 | "data": { 451 | "text/plain": [ 452 | "" 453 | ] 454 | }, 455 | "execution_count": 16, 456 | "metadata": {}, 457 | "output_type": "execute_result" 458 | }, 459 | { 460 | "data": { 461 | "image/png": "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\n", 462 | "text/plain": [ 463 | "" 464 | ] 465 | }, 466 | "metadata": { 467 | "needs_background": "light" 468 | }, 469 | "output_type": "display_data" 470 | } 471 | ], 472 | "source": [ 473 | "# scatter \n", 474 | "sns.regplot(x='Age', y='Fare', data=df.loc[(df['Pclass']==3) & \n", 475 | " (df['Sex']=='male')], fit_reg=True)" 476 | ] 477 | }, 478 | { 479 | "cell_type": "code", 480 | "execution_count": 17, 481 | "metadata": {}, 482 | "outputs": [ 483 | { 484 | "data": { 485 | "text/plain": [ 486 | "[96.385542168674704,\n", 487 | " 91.891891891891902,\n", 488 | " 46.078431372549019,\n", 489 | " 39.603960396039604,\n", 490 | " 15.151515151515152,\n", 491 | " 15.019762845849801]" 492 | ] 493 | }, 494 | "execution_count": 17, 495 | "metadata": {}, 496 | "output_type": "execute_result" 497 | } 498 | ], 499 | "source": [ 500 | "sex_survive=df.groupby(['Sex', 'Pclass']).Survived.mean()\n", 501 | "sex_survive=sex_survive*100\n", 502 | "my_list=list(sex_survive)\n", 503 | "my_list" 504 | ] 505 | }, 506 | { 507 | "cell_type": "code", 508 | "execution_count": 18, 509 | "metadata": {}, 510 | "outputs": [], 511 | "source": [ 512 | "# Convert to csv\n", 513 | "df.to_csv('titanic.csv')" 514 | ] 515 | }, 516 | { 517 | "cell_type": "code", 518 | "execution_count": null, 519 | "metadata": {}, 520 | "outputs": [], 521 | "source": [] 522 | }, 523 | { 524 | "cell_type": "code", 525 | "execution_count": null, 526 | "metadata": {}, 527 | "outputs": [], 528 | "source": [] 529 | }, 530 | { 531 | "cell_type": "code", 532 | "execution_count": null, 533 | "metadata": {}, 534 | "outputs": [], 535 | "source": [] 536 | }, 537 | { 538 | "cell_type": "code", 539 | "execution_count": null, 540 | "metadata": {}, 541 | "outputs": [], 542 | "source": [] 543 | } 544 | ], 545 | "metadata": { 546 | "kernelspec": { 547 | "display_name": "Python 3", 548 | "language": "python", 549 | "name": "python3" 550 | }, 551 | "language_info": { 552 | "codemirror_mode": { 553 | "name": "ipython", 554 | "version": 3 555 | }, 556 | "file_extension": ".py", 557 | "mimetype": "text/x-python", 558 | "name": "python", 559 | "nbconvert_exporter": "python", 560 | "pygments_lexer": "ipython3", 561 | "version": "3.6.7" 562 | } 563 | }, 564 | "nbformat": 4, 565 | "nbformat_minor": 2 566 | } 567 | -------------------------------------------------------------------------------- /02 basic dashboards/barchart_v1.py: -------------------------------------------------------------------------------- 1 | import dash 2 | import dash_core_components as dcc 3 | import dash_html_components as html 4 | 5 | app = dash.Dash() 6 | 7 | app.css.append_css({'external_url': 'https://codepen.io/chriddyp/pen/bWLwgP.css'}) 8 | app.title = 'Deloitte Dash' 9 | 10 | app.layout = html.Div(children=[ 11 | html.H1('Plotly Dash - the best way to visualize your data!'), 12 | dcc.Graph( 13 | id='this_is_an_id', 14 | figure={ 15 | 'data': [ 16 | {'x': ['Dash', 'Powerpoint', 'Lascaux cave paintings'], 'y': [8, 2, 3], 'type': 'bar', 'name': 'Intelligence'}, 17 | {'x': ['Dash', 'Powerpoint', 'Lascaux cave paintings'], 'y': [7, 1, 5], 'type': 'bar', 'name': 'Beauty'}, 18 | ], 19 | 'layout': { 20 | 'title': "Because friends don't let friends use Microsoft Powerpoint", 21 | 'xaxis':{'title':'Choice of data visualization'}, 22 | 'yaxis':{'title':'Approval rating by average data scientist'}, 23 | } 24 | } 25 | )] 26 | ) 27 | 28 | if __name__ == '__main__': 29 | app.run_server() 30 | -------------------------------------------------------------------------------- /02 basic dashboards/barchart_v2.py: -------------------------------------------------------------------------------- 1 | import dash 2 | import dash_core_components as dcc 3 | import dash_html_components as html 4 | import plotly.graph_objs as go 5 | 6 | ########### Set up the chart 7 | trace1 = go.Bar( 8 | x=['giraffes', 'orangutans', 'monkeys'], 9 | y=[20, 14, 23], 10 | name='SF Zoo' 11 | ) 12 | trace2 = go.Bar( 13 | x=['giraffes', 'orangutans', 'monkeys'], 14 | y=[12, 18, 29], 15 | name='LA Zoo' 16 | ) 17 | 18 | data = [trace1, trace2] 19 | layout = go.Layout( 20 | barmode='group' 21 | ) 22 | 23 | zoo_fig = go.Figure(data=data, layout=layout) 24 | 25 | ########### Display it in Dash 26 | 27 | 28 | app = dash.Dash() 29 | 30 | app.css.append_css({'external_url': 'https://codepen.io/chriddyp/pen/bWLwgP.css'}) 31 | app.title = 'Deloitte Dash' 32 | 33 | app.layout = html.Div(children=[ 34 | html.H1('My favorite zoo animals'), 35 | dcc.Graph( 36 | id='zoo_animals', 37 | figure=zoo_fig 38 | )] 39 | ) 40 | 41 | if __name__ == '__main__': 42 | app.run_server() 43 | 44 | # https://plot.ly/python/bar-charts/ 45 | -------------------------------------------------------------------------------- /02 basic dashboards/header and logo.py: -------------------------------------------------------------------------------- 1 | import dash 2 | import dash_core_components as dcc 3 | import dash_html_components as html 4 | import plotly.graph_objs as go 5 | import numpy as np 6 | import base64 7 | 8 | 9 | # Designate the image 10 | deloitte = base64.b64encode(open('../00 resources/Deloitte_logo.png', 'rb').read()) 11 | 12 | ########### Set up the chart 13 | # Example taken from: https://plot.ly/~rmfoster/88#code 14 | x = np.random.randn(500) 15 | data = [go.Histogram(x=x)] 16 | layout = go.Layout( 17 | title='This is a histogram about an IT survey', 18 | xaxis={'title':'How do you rate your satisfaction with Help Desk support?'}, 19 | yaxis={'title':'Survey Respondents'} 20 | ) 21 | fig = go.Figure(data=data, layout=layout) 22 | 23 | 24 | ########### Instantiate Dash 25 | 26 | app = dash.Dash() 27 | app.css.append_css({'external_url': 'https://codepen.io/chriddyp/pen/bWLwgP.css'}) 28 | app.title = 'Deloitte Dash' 29 | 30 | ########### APP LAYOUT ############ 31 | app.layout = html.Div([ 32 | # Header and logo 33 | html.Div([ 34 | html.Img( 35 | src='data:image/png;base64,{}'.format(deloitte.decode()), 36 | style={'height':'30px', 'padding-top': '10px', 'padding-left': '12px'} 37 | ) 38 | ], style={'height':'45px', 'backgroundColor': 'rgb(0,0,0)'}, className='twelve columns'), 39 | # Title 40 | html.H4('Satisfaction survey', style={'text-align':'left'}), 41 | # Body 42 | html.Div([ 43 | dcc.Graph( 44 | id='fig1', 45 | figure=fig, 46 | style={'height': '400px', 'align':'center'}) 47 | ], className='twelve columns'), 48 | # Footer 49 | dcc.Markdown('Code source: [Plotly Website](https://plot.ly/python/histograms/)', className='twelve columns'), 50 | html.Div([ 51 | html.Div('copyright © 2018', 52 | style={'color': 'rgb(255, 255, 255)', 53 | 'fontSize': 12, 54 | 'fontFamily':'Open Sans', 55 | 'font-weight': 'italic', 56 | 'text-align':'right', 57 | 'vertical-align': 'bottom', 58 | 'padding-right':'10px' 59 | }, 60 | className='twelve columns') 61 | ], style={'height':'30px', 'backgroundColor': 'rgb(0,0,0)'}, className='twelve columns') 62 | ]) 63 | 64 | ####### Execute 65 | if __name__ == '__main__': 66 | app.run_server() 67 | 68 | # https://plot.ly/python/reference/ 69 | -------------------------------------------------------------------------------- /02 basic dashboards/helloworld.py: -------------------------------------------------------------------------------- 1 | ''' 2 | A very simple dash app 3 | ''' 4 | 5 | ''' imports ''' 6 | import dash # dash is the framework, Dash is the class 7 | import dash_html_components as html # there are other dash libraries but this is the most basic 8 | 9 | ''' instantiate ''' 10 | app = dash.Dash() # Dash uses Flask as the web framework. The underlying Flask app is available at app.server 11 | 12 | ''' layout and functions ''' 13 | app.layout = html.Div('Goodbye Cruel World!') # All dash apps will begin with 'app.layout = '. Note the 'html' call. 14 | 15 | ''' execute ''' 16 | if __name__ == '__main__': # this ensures that the app is run only on execution, not on import 17 | app.run_server() 18 | -------------------------------------------------------------------------------- /02 basic dashboards/simple_flask.py: -------------------------------------------------------------------------------- 1 | ''' SIMPLE FLASK APP ''' 2 | 3 | 4 | ''' import the Class ''' 5 | from flask import Flask # flask is the framework here, while Flask is a Python class datatype. 6 | 7 | 8 | ''' instantiate the Class''' 9 | app = Flask(__name__) # once we import Flask, we need to create an instance of the Flask class for our web app. 10 | # __name__ is a special variable that gets as value the string "__main__" when you’re executing the script. 11 | # using "app" is an arbitrary convention, but be consistent. 12 | 13 | 14 | ''' define a function ''' 15 | @app.route('/my_app') # This line is a function decorator, mapping the function follows to localhost:5000/my_app 16 | def home(): # we define a function that returns the string “Hey there!”. 17 | return "Hey there!" 18 | 19 | 20 | ''' execute ''' 21 | if __name__ == '__main__': # This is only true when the script is executed. If it is imported, it will be false. 22 | app.run() # Prints out possible Python errors on the web page helping us trace the errors. Only use in Dev, not Prod. 23 | 24 | # Source: https://pythonhow.com/how-a-flask-app-works/ 25 | -------------------------------------------------------------------------------- /02 basic dashboards/two_charts.py: -------------------------------------------------------------------------------- 1 | 2 | import dash 3 | import dash_html_components as html 4 | import dash_core_components as dcc 5 | import plotly.graph_objs as go 6 | import numpy as np 7 | 8 | ################ Generate the line plot ########### 9 | 10 | data = [go.Scatter( 11 | x = ['Jan','Feb','Mar','Apr','May'], 12 | y = [3,2,5,4,7], 13 | mode = 'lines' 14 | )] 15 | layout = go.Layout( 16 | title = 'How often do I get new ideas?', 17 | xaxis={'title':'Months'}, 18 | yaxis={'title':'New Ideas'} 19 | ) 20 | line_plot = go.Figure(data=data,layout=layout) 21 | 22 | ############## Generate the scatter plot ########### 23 | 24 | # generate random data 25 | np.random.seed(42) 26 | random_x = np.random.randint(1,101,100) 27 | random_y = np.random.randint(1,31,30) 28 | 29 | # define the data 30 | data = [go.Scatter( 31 | x = random_x, 32 | y = random_y, 33 | mode = 'markers' 34 | )] 35 | # define the layout 36 | layout = go.Layout( 37 | title='Does anybody care about my ideas?', 38 | xaxis={'title':'Minutes I spent talking'}, 39 | yaxis={'title':'People who listened to me'} 40 | ) 41 | # combine data and layout into a dictionary 42 | scatter_plot = dict(data=data, layout=layout ) 43 | 44 | ######### Dash App ########### 45 | app = dash.Dash() 46 | app.title = '2-box dash app' 47 | app.css.append_css({'external_url': 'https://codepen.io/chriddyp/pen/bWLwgP.css'}) # CSS style sheet 48 | 49 | app.layout = html.Div([ 50 | dcc.Graph( 51 | id='scatter', 52 | figure=line_plot, 53 | className='six columns'), 54 | dcc.Graph( 55 | id='line', 56 | figure=scatter_plot, 57 | className='six columns') 58 | ]) 59 | 60 | if __name__ == '__main__': 61 | app.run_server(debug=True) 62 | -------------------------------------------------------------------------------- /03 callbacks/callback with state.py: -------------------------------------------------------------------------------- 1 | ####### 2 | # A very basic Input/Output callback, with State! 3 | ###### 4 | import dash 5 | import dash_core_components as dcc 6 | import dash_html_components as html 7 | from dash.dependencies import Input, Output, State 8 | 9 | app = dash.Dash() 10 | 11 | app.layout = html.Div([ 12 | dcc.Input( 13 | id='number-in', 14 | value=1, 15 | style={'fontSize':28} 16 | ), 17 | html.Button( 18 | id='submit-button', 19 | n_clicks=0, 20 | children='Submit', 21 | style={'fontSize':28} 22 | ), 23 | html.H1(id='number-out') 24 | ]) 25 | 26 | @app.callback( 27 | Output('number-out', 'children'), 28 | [Input('submit-button', 'n_clicks')], 29 | [State('number-in', 'value')]) 30 | def output(n_clicks, number): 31 | return '{} displayed after {} clicks'.format(number,n_clicks) 32 | 33 | if __name__ == '__main__': 34 | app.run_server() 35 | -------------------------------------------------------------------------------- /03 callbacks/simple callback.py: -------------------------------------------------------------------------------- 1 | ''' 2 | A simple callback example 3 | ''' 4 | 5 | # imports 6 | import dash 7 | import dash_core_components as dcc 8 | import dash_html_components as html 9 | from dash.dependencies import Input, Output 10 | 11 | # instantiate 12 | app = dash.Dash() 13 | 14 | # layout 15 | app.layout = html.Div([ 16 | dcc.Input(id='my-id', value='initial value', type='text'), 17 | html.Div(id='my-div') 18 | ]) 19 | 20 | # callback decorators and functions 21 | @app.callback( 22 | Output(component_id='my-div', component_property='children'), 23 | [Input(component_id='my-id', component_property='value')] 24 | ) 25 | def update_output_div(input_value): 26 | return 'You\'ve entered "{}"'.format(input_value) 27 | 28 | # execute 29 | if __name__ == '__main__': 30 | app.run_server() 31 | -------------------------------------------------------------------------------- /03 callbacks/slider.py: -------------------------------------------------------------------------------- 1 | import dash 2 | import dash_auth 3 | import dash_core_components as dcc 4 | import dash_html_components as html 5 | from dash.dependencies import Input, Output 6 | 7 | USERNAME_PASSWORD_PAIRS = [ 8 | ['JamesBond', '007'],['LouisArmstrong', 'satchmo'] 9 | ] 10 | 11 | app = dash.Dash() 12 | auth = dash_auth.BasicAuth(app,USERNAME_PASSWORD_PAIRS) 13 | server = app.server 14 | 15 | app.layout = html.Div([ 16 | dcc.RangeSlider( 17 | id='range-slider', 18 | min=-5, 19 | max=6, 20 | marks={i:str(i) for i in range(-5, 7)}, 21 | value=[-3, 4] 22 | ), 23 | html.H1(id='product') # this is the output 24 | ], style={'width':'50%'}) 25 | 26 | @app.callback( 27 | Output('product', 'children'), 28 | [Input('range-slider', 'value')]) 29 | def update_value(value_list): 30 | return value_list[0]*value_list[1] 31 | 32 | if __name__ == '__main__': 33 | app.run_server(debug = True) 34 | -------------------------------------------------------------------------------- /04 visualize pandas/pandas_example1.py: -------------------------------------------------------------------------------- 1 | 2 | # imports 3 | import dash 4 | import dash_core_components as dcc 5 | import dash_html_components as html 6 | 7 | import pandas as pd 8 | 9 | # read in the dataset 10 | source="../00 resources/titanic.csv" 11 | df=pd.read_csv(source) 12 | # group survival results by sex and cabin class 13 | sex_survive=df.groupby(['Sex', 'Pclass']).Survived.mean() 14 | sex_survive=sex_survive*100 15 | mylist=list(sex_survive) 16 | 17 | # instantiate the class 18 | app = dash.Dash() 19 | app.css.append_css({'external_url': 'https://codepen.io/chriddyp/pen/bWLwgP.css'}) 20 | app.title = 'Titanic!' 21 | 22 | # define the layout 23 | app.layout = html.Div(children=[ 24 | html.H1(children='Titanic!'), 25 | html.Div(children='Who survived the sinking of the Titanic?'), 26 | dcc.Graph( 27 | id='titanic-graph', 28 | figure={ 29 | 'data': [ 30 | {'x': ['1st Class', '2nd Class', '3rd Class'], 'y': [mylist[0], mylist[1], mylist[2]], 'type': 'bar', 'name': 'Female'}, 31 | {'x': ['1st Class', '2nd Class', '3rd Class'], 'y': [mylist[3], mylist[4], mylist[5]], 'type': 'bar', 'name': 'Male'}, 32 | ], 33 | 'layout': { 34 | 'title': 'Survival Rate by Sex', 35 | 'xaxis':{'title':'Cabin Class'}, 36 | 'yaxis':{'title':'Percentage Survival'}, 37 | } 38 | } 39 | ), 40 | html.H1('this is another heading') 41 | ]) 42 | 43 | # execute 44 | if __name__ == '__main__': 45 | app.run_server() 46 | -------------------------------------------------------------------------------- /04 visualize pandas/pandas_example2.py: -------------------------------------------------------------------------------- 1 | 2 | # imports 3 | import dash 4 | import dash_core_components as dcc 5 | import dash_html_components as html 6 | import plotly.graph_objs as go 7 | import pandas as pd 8 | 9 | # read in the dataset 10 | source="../00 resources/titanic.csv" 11 | df=pd.read_csv(source) 12 | 13 | # Build the Figure using Plotly Graph Objects 14 | data = [go.Bar( 15 | x=df['Pclass'], 16 | y=df['Fare'] 17 | )] 18 | layout = go.Layout( 19 | title='How much did Titanic passengers pay?', 20 | xaxis = {'title': 'What deck class were they?'}, 21 | yaxis = {'title': 'What was their average fare?'}, 22 | ) 23 | my_fig = go.Figure(data=data, layout=layout) 24 | 25 | 26 | # instantiate 27 | app = dash.Dash() 28 | 29 | # layout 30 | app.layout = dcc.Graph(id='scatterplot2', figure = my_fig) 31 | 32 | # execute 33 | if __name__ == '__main__': 34 | app.run_server() 35 | -------------------------------------------------------------------------------- /04 visualize pandas/table_format_new.py: -------------------------------------------------------------------------------- 1 | # pip install dash-table==3.1.2 2 | import dash 3 | import dash_table 4 | import dash_html_components as html 5 | import dash_core_components as dcc 6 | import pandas as pd 7 | 8 | # read in the dataset 9 | source="../00 resources/titanic.csv" 10 | df=pd.read_csv(source) 11 | df=df.loc[df['Age']>30] # Let's subset the age 12 | 13 | # instantiate 14 | app = dash.Dash(__name__) 15 | 16 | # layout 17 | app.layout = html.Div([ 18 | html.H1('Titanic Dataset'), 19 | dash_table.DataTable( 20 | id='table', 21 | columns=[{"name": i, "id": i} for i in df.columns], 22 | data=df.to_dict("rows"), 23 | ) 24 | ]) 25 | 26 | # execute 27 | if __name__ == '__main__': 28 | app.run_server(debug=True) 29 | 30 | # https://dash.plot.ly/datatable 31 | -------------------------------------------------------------------------------- /04 visualize pandas/table_format_old.py: -------------------------------------------------------------------------------- 1 | 2 | # imports 3 | import dash 4 | import dash_core_components as dcc 5 | import dash_html_components as html 6 | import pandas as pd 7 | 8 | # read in the dataset 9 | source="../00 resources/titanic.csv" 10 | df=pd.read_csv(source) 11 | 12 | # define a function to display table 13 | def generate_table(dataframe): 14 | return html.Table( 15 | # Header 16 | [html.Tr([html.Th(col) for col in dataframe.columns])] + 17 | # Body 18 | [html.Tr([ 19 | html.Td(dataframe.iloc[i][col]) for col in dataframe.columns 20 | ]) for i in range(len(dataframe))] 21 | ) 22 | 23 | # instantiate 24 | app = dash.Dash() 25 | 26 | # layout 27 | app.layout = html.Div(generate_table(df)) 28 | 29 | # execute 30 | if __name__ == '__main__': 31 | app.run_server() 32 | -------------------------------------------------------------------------------- /05 tabs and pages/multi-page app/home.py: -------------------------------------------------------------------------------- 1 | import dash 2 | import dash_core_components as dcc 3 | import dash_html_components as html 4 | from dash.dependencies import Input, Output 5 | from pages import index 6 | from pages import page_1 7 | from pages import page_2 8 | 9 | print(dcc.__version__) # 0.6.0 or above is required 10 | 11 | app = dash.Dash() 12 | 13 | app.config.suppress_callback_exceptions = True 14 | 15 | app.layout = html.Div([ 16 | dcc.Location(id='url', refresh=False), 17 | html.Div(id='page-content') 18 | ]) 19 | 20 | # Page 1 callback 21 | @app.callback(dash.dependencies.Output('page-1-content', 'children'), 22 | [dash.dependencies.Input('page-1-dropdown', 'value')]) 23 | def page_1_dropdown(value): 24 | return 'You have selected "{}"'.format(value) 25 | 26 | # Page 2 callback 27 | @app.callback(Output('page-2-content', 'children'), 28 | [Input('page-2-radios', 'value')]) 29 | def page_2_radios(value): 30 | return 'You have selected "{}"'.format(value) 31 | 32 | # Index Page callback 33 | @app.callback(Output('page-content', 'children'), 34 | [Input('url', 'pathname')]) 35 | def display_page(pathname): 36 | if pathname == '/page-1': 37 | return page_1.page_1_layout 38 | elif pathname == '/page-2': 39 | return page_2.page_2_layout 40 | else: 41 | return '404' 42 | 43 | app.css.append_css({ 44 | 'external_url': 'https://codepen.io/chriddyp/pen/bWLwgP.css' 45 | }) 46 | 47 | 48 | if __name__ == '__main__': 49 | app.run_server(debug=True) 50 | -------------------------------------------------------------------------------- /05 tabs and pages/multi-page app/multipage_app.py: -------------------------------------------------------------------------------- 1 | import dash 2 | import dash_core_components as dcc 3 | import dash_html_components as html 4 | 5 | print(dcc.__version__) # 0.6.0 or above is required 6 | 7 | app = dash.Dash() 8 | 9 | # Since we're adding callbacks to elements that don't exist in the app.layout, 10 | # Dash will raise an exception to warn us that we might be 11 | # doing something wrong. 12 | # In this case, we're adding the elements through a callback, so we can ignore 13 | # the exception. 14 | app.config.suppress_callback_exceptions = True 15 | 16 | app.layout = html.Div([ 17 | dcc.Location(id='url', refresh=False), 18 | html.Div(id='page-content') 19 | ]) 20 | 21 | 22 | index_page = html.Div([ 23 | dcc.Link('Go to Page 1', href='/page-1'), 24 | html.Br(), 25 | dcc.Link('Go to Page 2', href='/page-2'), 26 | ]) 27 | 28 | page_1_layout = html.Div([ 29 | html.H1('Page 1'), 30 | dcc.Dropdown( 31 | id='page-1-dropdown', 32 | options=[{'label': i, 'value': i} for i in ['LA', 'NYC', 'MTL']], 33 | value='LA' 34 | ), 35 | html.Div(id='page-1-content'), 36 | html.Br(), 37 | dcc.Link('Go to Page 2', href='/page-2'), 38 | html.Br(), 39 | dcc.Link('Go back to home', href='/'), 40 | 41 | ]) 42 | 43 | @app.callback(dash.dependencies.Output('page-1-content', 'children'), 44 | [dash.dependencies.Input('page-1-dropdown', 'value')]) 45 | def page_1_dropdown(value): 46 | return 'You have selected "{}"'.format(value) 47 | 48 | 49 | page_2_layout = html.Div([ 50 | html.H1('Page 2'), 51 | dcc.RadioItems( 52 | id='page-2-radios', 53 | options=[{'label': i, 'value': i} for i in ['Orange', 'Blue', 'Red']], 54 | value='Orange' 55 | ), 56 | html.Div(id='page-2-content'), 57 | html.Br(), 58 | dcc.Link('Go to Page 1', href='/page-1'), 59 | html.Br(), 60 | dcc.Link('Go back to home', href='/') 61 | ]) 62 | 63 | @app.callback(dash.dependencies.Output('page-2-content', 'children'), 64 | [dash.dependencies.Input('page-2-radios', 'value')]) 65 | def page_2_radios(value): 66 | return 'You have selected "{}"'.format(value) 67 | 68 | 69 | # Update the index 70 | @app.callback(dash.dependencies.Output('page-content', 'children'), 71 | [dash.dependencies.Input('url', 'pathname')]) 72 | def display_page(pathname): 73 | if pathname == '/page-1': 74 | return page_1_layout 75 | elif pathname == '/page-2': 76 | return page_2_layout 77 | else: 78 | return index_page 79 | # You could also return a 404 "URL not found" page here 80 | 81 | app.css.append_css({ 82 | 'external_url': 'https://codepen.io/chriddyp/pen/bWLwgP.css' 83 | }) 84 | 85 | 86 | if __name__ == '__main__': 87 | app.run_server(debug=True) 88 | -------------------------------------------------------------------------------- /05 tabs and pages/multi-page app/pages/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/austinlasseter/plotly_dash_tutorial/f7ac5540ee970d7ac77f0fc1273f2ab670d1bb9d/05 tabs and pages/multi-page app/pages/__init__.py -------------------------------------------------------------------------------- /05 tabs and pages/multi-page app/pages/index.py: -------------------------------------------------------------------------------- 1 | import dash 2 | import dash_core_components as dcc 3 | import dash_html_components as html 4 | from dash.dependencies import Input, Output 5 | 6 | index_page = html.Div([ 7 | dcc.Link('Go to Page 1', href='/page-1'), 8 | html.Br(), 9 | dcc.Link('Go to Page 2', href='/page-2'), 10 | ]) 11 | -------------------------------------------------------------------------------- /05 tabs and pages/multi-page app/pages/page_1.py: -------------------------------------------------------------------------------- 1 | import dash 2 | import dash_core_components as dcc 3 | import dash_html_components as html 4 | from dash.dependencies import Input, Output 5 | 6 | page_1_layout = html.Div([ 7 | html.H1('Page 1'), 8 | dcc.Dropdown( 9 | id='page-1-dropdown', 10 | options=[{'label': i, 'value': i} for i in ['LA', 'NYC', 'MTL']], 11 | value='LA' 12 | ), 13 | html.Div(id='page-1-content'), 14 | html.Br(), 15 | dcc.Link('Go to Page 2', href='/page-2'), 16 | html.Br(), 17 | dcc.Link('Go back to home', href='/'), 18 | 19 | ]) 20 | -------------------------------------------------------------------------------- /05 tabs and pages/multi-page app/pages/page_2.py: -------------------------------------------------------------------------------- 1 | import dash 2 | import dash_core_components as dcc 3 | import dash_html_components as html 4 | from dash.dependencies import Input, Output 5 | 6 | page_2_layout = html.Div([ 7 | html.H1('Page 2'), 8 | dcc.RadioItems( 9 | id='page-2-radios', 10 | options=[{'label': i, 'value': i} for i in ['Orange', 'Blue', 'Red']], 11 | value='Orange' 12 | ), 13 | html.Div(id='page-2-content'), 14 | html.Br(), 15 | dcc.Link('Go to Page 1', href='/page-1'), 16 | html.Br(), 17 | dcc.Link('Go back to home', href='/') 18 | ]) 19 | -------------------------------------------------------------------------------- /05 tabs and pages/multi-tab app/main.py: -------------------------------------------------------------------------------- 1 | import dash 2 | from dash.dependencies import Input, Output 3 | import dash_html_components as html 4 | import dash_core_components as dcc 5 | from tabs import tab_1 6 | from tabs import tab_2 7 | 8 | app = dash.Dash() 9 | 10 | app.config['suppress_callback_exceptions'] = True 11 | 12 | app.layout = html.Div([ 13 | html.H1('Dash Tabs component demo'), 14 | dcc.Tabs(id="tabs-example", value='tab-1-example', children=[ 15 | dcc.Tab(label='Tab One', value='tab-1-example'), 16 | dcc.Tab(label='Tab Two', value='tab-2-example'), 17 | ]), 18 | html.Div(id='tabs-content-example') 19 | ]) 20 | 21 | @app.callback(Output('tabs-content-example', 'children'), 22 | [Input('tabs-example', 'value')]) 23 | def render_content(tab): 24 | if tab == 'tab-1-example': 25 | return tab_1.tab_1_layout 26 | elif tab == 'tab-2-example': 27 | return tab_2.tab_2_layout 28 | 29 | # Tab 1 callback 30 | @app.callback(dash.dependencies.Output('page-1-content', 'children'), 31 | [dash.dependencies.Input('page-1-dropdown', 'value')]) 32 | def page_1_dropdown(value): 33 | return 'You have selected "{}"'.format(value) 34 | 35 | # Tab 2 callback 36 | @app.callback(Output('page-2-content', 'children'), 37 | [Input('page-2-radios', 'value')]) 38 | def page_2_radios(value): 39 | return 'You have selected "{}"'.format(value) 40 | 41 | app.css.append_css({ 42 | 'external_url': 'https://codepen.io/chriddyp/pen/bWLwgP.css' 43 | }) 44 | 45 | if __name__ == '__main__': 46 | app.run_server(debug=True) 47 | -------------------------------------------------------------------------------- /05 tabs and pages/multi-tab app/tabs/tab_1.py: -------------------------------------------------------------------------------- 1 | import dash 2 | import dash_core_components as dcc 3 | import dash_html_components as html 4 | from dash.dependencies import Input, Output 5 | 6 | tab_1_layout = html.Div([ 7 | html.H1('Page 1'), 8 | dcc.Dropdown( 9 | id='page-1-dropdown', 10 | options=[{'label': i, 'value': i} for i in ['LA', 'NYC', 'MTL']], 11 | value='LA' 12 | ), 13 | html.Div(id='page-1-content') 14 | ]) 15 | -------------------------------------------------------------------------------- /05 tabs and pages/multi-tab app/tabs/tab_2.py: -------------------------------------------------------------------------------- 1 | import dash 2 | import dash_core_components as dcc 3 | import dash_html_components as html 4 | from dash.dependencies import Input, Output 5 | 6 | tab_2_layout = html.Div([ 7 | html.H1('Page 2'), 8 | dcc.RadioItems( 9 | id='page-2-radios', 10 | options=[{'label': i, 'value': i} for i in ['Orange', 'Blue', 'Red']], 11 | value='Orange' 12 | ), 13 | html.Div(id='page-2-content') 14 | ]) 15 | -------------------------------------------------------------------------------- /06 Heroku examples/list of resources.md: -------------------------------------------------------------------------------- 1 | ## Simple dash apps to fork and imitate 2 | This page presents a collection of very simple dash apps, designed for learning purposes. Each has an embedded link to its source code on github. Students can fork the code on github, modify the `app.py` file, and deploy their own version on Heroku. [Here's a Medium post](https://medium.com/@austinlasseter/how-to-deploy-a-simple-plotly-dash-app-to-heroku-622a2216eb73) describing how to do that. 3 | 4 | ## Simple Dash apps (no callbacks, no pandas) 5 | * https://zoo-animals-dash.herokuapp.com/ 6 | * https://flying-dog.herokuapp.com/ 7 | * https://example-donut-chart.herokuapp.com/ 8 | * https://dash-linechart-example.herokuapp.com/ 9 | * https://back2good-dc-metro.herokuapp.com/ 10 | 11 | ## Dash apps with simple callbacks 12 | * https://dash-simple-callback.herokuapp.com 13 | * https://chuck-norris-execution.herokuapp.com/ 14 | * https://dash-radio-callback.herokuapp.com/ 15 | 16 | ## More advanced callbacks 17 | * * https://lightsaber-chooser.herokuapp.com/ 18 | * https://dash-multitab-example.herokuapp.com/ 19 | * https://dash-daq-state.herokuapp.com/ 20 | 21 | ## Dash apps with Pandas 22 | * https://virginia-2016-vote-totals.herokuapp.com/ 23 | * https://scatterplot-dc-housing.herokuapp.com 24 | * https://data-table-beer-example.herokuapp.com/ 25 | * https://my-test-pandas-app-123.herokuapp.com/ 26 | 27 | ## Dash apps with maps 28 | * https://dc-properties-map.herokuapp.com/ 29 | * https://virginia-census-data.herokuapp.com/ 30 | * https://dash-density-heatmap-dc.herokuapp.com/ 31 | * https://iowa-has-lots-of-corn.herokuapp.com/ 32 | * https://va-opioid-dashboard.herokuapp.com/ 33 | * https://dash-density-heatmap.herokuapp.com/ 34 | * https://obscure-brook-30801.herokuapp.com/ 35 | 36 | ## Dash apps for machine learning models 37 | * https://knn-iris-classifier.herokuapp.com/ 38 | * http://titanicclassifier-env.g8sipcfcmu.us-east-1.elasticbeanstalk.com/ 39 | * http://python-eda-example.us-east-1.elasticbeanstalk.com/ 40 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Getting Started with Plotly Dash 2 | 3 | #### Course Description 4 | Dash is a Python framework for building analytical web applications. Dash ties modern UI elements like dropdowns, sliders, and graphs to your Python code. In this class, participants will learn how to build a simple Dash application and deploy it online. 5 | 6 | ## Simple dash apps to fork and imitate 7 | This page presents a collection of very simple dash apps, designed for learning purposes. Each has an embedded link to its source code on github. Students can fork the code on github, modify the `app.py` file, and deploy their own version on Heroku. [Here's a Medium post](https://medium.com/@austinlasseter/how-to-deploy-a-simple-plotly-dash-app-to-heroku-622a2216eb73) describing how to do that. 8 | 9 | ## Simple (no callbacks, no pandas) 10 | * https://zoo-animals-dash.herokuapp.com/ 11 | * https://flying-dog.herokuapp.com/ 12 | * https://example-donut-chart.herokuapp.com/ 13 | * https://dash-linechart-example.herokuapp.com/ 14 | * https://back2good-dc-metro.herokuapp.com/ 15 | * for elastic beanstalk: https://github.com/austinlasseter/elastic-beanstalk-dash-app 16 | 17 | ## Dash apps with simple callbacks 18 | * https://dash-simple-callback.herokuapp.com 19 | * https://chuck-norris-execution.herokuapp.com/ 20 | * https://dash-radio-callback.herokuapp.com/ 21 | 22 | ## More advanced callbacks 23 | * https://lightsaber-chooser.herokuapp.com/ 24 | * https://dash-multitab-example.herokuapp.com/ 25 | * https://dash-daq-state.herokuapp.com/ 26 | 27 | ## Dash apps with Pandas 28 | * https://virginia-2016-vote-totals.herokuapp.com/ 29 | * https://scatterplot-dc-housing.herokuapp.com 30 | * https://data-table-beer-example.herokuapp.com/ 31 | * https://my-test-pandas-app-123.herokuapp.com/ 32 | 33 | ## Dash apps with maps 34 | * https://dc-properties-map.herokuapp.com/ 35 | * https://virginia-census-data.herokuapp.com/ 36 | * https://dash-density-heatmap-dc.herokuapp.com/ 37 | * https://iowa-has-lots-of-corn.herokuapp.com/ 38 | * https://va-opioid-dashboard.herokuapp.com/ 39 | * https://dash-density-heatmap.herokuapp.com/ 40 | * https://obscure-brook-30801.herokuapp.com/ 41 | 42 | ## Dash apps for machine learning models 43 | * https://knn-iris-classifier.herokuapp.com/ 44 | * https://tmdb-rf-genres.herokuapp.com/ 45 | * http://titanicclassifier-env.g8sipcfcmu.us-east-1.elasticbeanstalk.com/ 46 | * http://python-eda-example.us-east-1.elasticbeanstalk.com/ 47 | 48 | 49 | #### Installation 50 | [Anaconda](https://www.anaconda.com/download/) 51 | [Dash by Plotly](https://dash.plot.ly/installation) 52 | [Atom by Github](https://atom.io) 53 | For deploying to the cloud, you'll also need: 54 | [Git](https://git-scm.com/downloads) 55 | [Heroku](https://devcenter.heroku.com/articles/heroku-cli#download-and-install) -- You'll also need to open a [free Heroku account](https://signup.heroku.com/dc) 56 | pip install virtualenv 57 | 58 | #### Official Resources from Plotly: 59 | [Introducing Plotly Dash](https://medium.com/@plotlygraphs/introducing-dash-5ecf7191b503) 60 | [Youtube: Dash in 5 minutes](https://www.youtube.com/watch?v=e4ti2fCpXMI) 61 | [Dash User Guide](https://dash.plot.ly/) 62 | [Dash Workshop, Washington DC Edition - June 9-10, 2018](https://dash-workshop.plot.ly/) 63 | [Chris Parmer's github repo for Dash](https://github.com/plotly/dash-docs) 64 | [Dash Community Forum - like StackOverflow for Dash](https://community.plot.ly/c/dash) 65 | [Gallery of Dash apps](https://dash.plot.ly/gallery) 66 | 67 | #### Additional resources for learning Dash 68 | [Dash Workbook by Jose Portilla](https://docs.google.com/document/d/1DjWL2DxLiRaBrlD3ELyQlCBRu7UQuuWfgjv9LncNp_M/edit) 69 | [Github Repo by Jose Portilla](https://github.com/Pierian-Data/Plotly-Dashboards-with-Dash) 70 | [Bokeh vs. Dash](https://blog.sicara.com/bokeh-dash-best-dashboard-framework-python-shiny-alternative-c5b576375f7f) 71 | [Using Dash to build public sector dashboards](https://medium.com/a-r-g-o/using-plotlys-dash-to-deliver-public-sector-decision-support-dashboards-ac863fa829fb) 72 | [How a Flask app works](https://pythonhow.com/how-a-flask-app-works/) 73 | 74 | #### Cloud Deployment 75 | [Example of a simple deployed app](https://github.com/austinlasseter/simple_dash_app) 76 | [How to deploy a Dash using AWS command line](https://medium.com/@austinlasseter/plotly-dash-and-the-elastic-beanstalk-command-line-89fb6b67bb79) 77 | [How to deploy a Dash app using AWS GUI console](https://medium.com/@austinlasseter/deploying-a-dash-app-with-elastic-beanstalk-console-27a834ebe91d) 78 | [How to deploy a Dash app using Heroku](https://dash.plot.ly/deployment) 79 | [AWS Elastic Beanstalk Command Line](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/eb-cli3-install-windows.html) 80 | [Heroku Command Line](https://devcenter.heroku.com/articles/heroku-cli) 81 | --------------------------------------------------------------------------------