├── 2021
├── PE1 Module 1 - Pengenalan Python dan Bahasa Pemrograman.ipynb
├── PE1 Module 2 - Tipe Data, Variabel, Dasar Input Output, Operasi.ipynb
├── PE1 Module 3 - Operator kondisi, perulangan, list dan operasinya, bitwise, boolean.ipynb
├── PE1 Module 4 - Function Tuple Dictionaries and Data Processing.ipynb
├── PE2 Module 1 - Modules, Packages and PIP.ipynb
├── PE2 Module 2 - Exceptions, Strings, String and List Methods.ipynb
├── PE2 Module 3 - Pemrograman Berbasis Obyek (PBO).ipynb
├── PE2 Module 4 - Miscellaneous.ipynb
├── PPT
│ ├── 01 Pengenalan Pemograman Python.pdf
│ └── readme.md
└── readme.md
├── .ipynb_checkpoints
├── Modul 1 - Pengenalan Python dan Bahasa Pemrograman-checkpoint.ipynb
└── Modul 2 - Tipe Data, Variabel, Dasar Input Output, Operasi-checkpoint.ipynb
├── Modul 1 - Pengenalan Python dan Bahasa Pemrograman.ipynb
├── Modul 2 - Tipe Data, Variabel, Dasar Input Output, Operasi.ipynb
├── Modul 3 - Operator kondisi, perulangan, list dan operasinya, bitwise, boolean.ipynb
├── Modul 4 - Function Tuple Dictionaries and Data Processing.ipynb
├── Modul 5 - Modules, packages, string and list methods, and exceptions.ipynb
├── Modul_6_OOP_and_file_operation.ipynb
├── PE2M1 - Modules, Packages and PIPExternal tool.ipynb
├── PE2M2 - Strings, String and List Methods, ExceptionsExternal tool2.ipynb
├── Python Essentials 2 - Module 3.ipynb
├── Python Essentials 2 - Module 4.ipynb
├── README.md
├── _config.yml
├── asets
├── colab.png
├── cth.txt
├── diamond.png
├── enkrip.jpg
├── filehandle.png
├── filename.png
├── files.png
├── filestream.png
├── inheritance.png
├── iobase.png
├── leapyear.png
├── linkaran.png
├── max.png
├── osmodule.png
├── p1_pilot.json
├── persegilink.png
├── pycalendar.png
├── pycalendar2.png
├── pydatetime.png
└── stack.png
├── class1.JPG
├── class2.JPG
├── inheritance.JPG
├── project
├── DTS_project1_warmup_assignment_warmup.ipynb
├── Numpy_tutorial.ipynb
├── QnA_gado2_30062020.ipynb
├── README.md
├── Warm_up_p2.ipynb
└── p1.py
└── utils
├── autograder.py
└── sapa.py
/.ipynb_checkpoints/Modul 1 - Pengenalan Python dan Bahasa Pemrograman-checkpoint.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## Luaran Pembelajaran\n",
8 | "- dasar-dasar pemrograman komputer;\n",
9 | "- mengatur lingkungan pemrograman;\n",
10 | "- compilation vs interpretation;\n",
11 | "- pengantar bahasa pemrograman Python.\n",
12 | "\n",
13 | "#### Masuk ke Slide Power Point"
14 | ]
15 | },
16 | {
17 | "cell_type": "code",
18 | "execution_count": 2,
19 | "metadata": {},
20 | "outputs": [
21 | {
22 | "name": "stdout",
23 | "output_type": "stream",
24 | "text": [
25 | "Hello World\n"
26 | ]
27 | }
28 | ],
29 | "source": [
30 | "# Your First Program\n",
31 | "\n",
32 | "print(\"Hello World\")"
33 | ]
34 | }
35 | ],
36 | "metadata": {
37 | "kernelspec": {
38 | "display_name": "Python 3",
39 | "language": "python",
40 | "name": "python3"
41 | },
42 | "language_info": {
43 | "codemirror_mode": {
44 | "name": "ipython",
45 | "version": 3
46 | },
47 | "file_extension": ".py",
48 | "mimetype": "text/x-python",
49 | "name": "python",
50 | "nbconvert_exporter": "python",
51 | "pygments_lexer": "ipython3",
52 | "version": "3.7.4"
53 | }
54 | },
55 | "nbformat": 4,
56 | "nbformat_minor": 2
57 | }
58 |
--------------------------------------------------------------------------------
/2021/PE1 Module 1 - Pengenalan Python dan Bahasa Pemrograman.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## Luaran Pembelajaran\n",
8 | "klik untuk [Open in colab](https://colab.research.google.com/github/sykrn/py-dts/blob/master/Modul%201%20-%20Pengenalan%20Python%20dan%20Bahasa%20Pemrograman.ipynb) \n",
9 | "- dasar-dasar pemrograman komputer;\n",
10 | "- mengatur lingkungan pemrograman;\n",
11 | "- compilation vs interpretation;\n",
12 | "- pengantar bahasa pemrograman Python.\n",
13 | "\n",
14 | "#### Masuk ke Slide Power Point"
15 | ]
16 | },
17 | {
18 | "cell_type": "code",
19 | "execution_count": 2,
20 | "metadata": {},
21 | "outputs": [
22 | {
23 | "name": "stdout",
24 | "output_type": "stream",
25 | "text": [
26 | "Hello World\n"
27 | ]
28 | }
29 | ],
30 | "source": [
31 | "# Your First Program\n",
32 | "\n",
33 | "print(\"Hello World\")"
34 | ]
35 | },
36 | {
37 | "cell_type": "markdown",
38 | "metadata": {},
39 | "source": [
40 | "## Instalasi python dan tools\n",
41 | "Cara dibawah ini pilih salah satu:\n",
42 | "\n",
43 | "1. Tidak perlu install apapun -> Pakai **sandbox** atau **Google Colab** (klik link colab setiap notebook)\n",
44 | "2. Install minimal python -> download di [python.org](https://www.python.org/) (Sudah termasuk package manager pip dan IDLE)\n",
45 | "> Saat menginstall, silakan centang **add to path variable** dan **change minimum path length** \n",
46 | "3. Install miniconda (minimum anaconda) - Command Line Interface (CLI) only [miniconda](https://docs.conda.io/en/latest/miniconda.html)\n",
47 | "4. Install Anaconda - Graphical User Interface (GUI) (sudah bisa install spyder, VSCode, dll) [download](https://www.anaconda.com/products/individual)\n",
48 | "\n",
49 | "### Editor & working space \n",
50 | "1. IDLE dari python.org\n",
51 | "2. Visual Studio Code -> Rcmd: install ekstensi `python` dari microsoft. [download](https://code.visualstudio.com/)\n",
52 | "3. Jupyter notebook di CLI baik menggunakan `pip` atau `conda`. [Install](https://jupyter.org/install)\n",
53 | "\n",
54 | "### CLI only untuk linux\n",
55 | "* bisa menggunakan `curl` atau `wget`"
56 | ]
57 | },
58 | {
59 | "cell_type": "markdown",
60 | "metadata": {},
61 | "source": [
62 | "# Pengenalan Jupyter Notebook"
63 | ]
64 | },
65 | {
66 | "cell_type": "code",
67 | "execution_count": 1,
68 | "metadata": {},
69 | "outputs": [
70 | {
71 | "data": {
72 | "text/plain": [
73 | "3"
74 | ]
75 | },
76 | "execution_count": 1,
77 | "metadata": {},
78 | "output_type": "execute_result"
79 | }
80 | ],
81 | "source": [
82 | "1+2"
83 | ]
84 | },
85 | {
86 | "cell_type": "code",
87 | "execution_count": 2,
88 | "metadata": {},
89 | "outputs": [
90 | {
91 | "data": {
92 | "text/plain": [
93 | "8"
94 | ]
95 | },
96 | "execution_count": 2,
97 | "metadata": {},
98 | "output_type": "execute_result"
99 | }
100 | ],
101 | "source": [
102 | "2**3"
103 | ]
104 | },
105 | {
106 | "cell_type": "code",
107 | "execution_count": null,
108 | "metadata": {},
109 | "outputs": [],
110 | "source": [
111 | "# komen"
112 | ]
113 | },
114 | {
115 | "cell_type": "markdown",
116 | "metadata": {},
117 | "source": [
118 | "## Ini markdown\n",
119 | "\n",
120 | "Bisa Juga digunakan untuk menulis persamaan dengan menggunakan syntax LATEX: $\\int_a^b f(x) dx$"
121 | ]
122 | },
123 | {
124 | "cell_type": "code",
125 | "execution_count": null,
126 | "metadata": {},
127 | "outputs": [],
128 | "source": []
129 | }
130 | ],
131 | "metadata": {
132 | "kernelspec": {
133 | "display_name": "Python 3",
134 | "language": "python",
135 | "name": "python3"
136 | },
137 | "language_info": {
138 | "codemirror_mode": {
139 | "name": "ipython",
140 | "version": 3
141 | },
142 | "file_extension": ".py",
143 | "mimetype": "text/x-python",
144 | "name": "python",
145 | "nbconvert_exporter": "python",
146 | "pygments_lexer": "ipython3",
147 | "version": "3.8.3"
148 | }
149 | },
150 | "nbformat": 4,
151 | "nbformat_minor": 2
152 | }
153 |
--------------------------------------------------------------------------------
/2021/PE1 Module 2 - Tipe Data, Variabel, Dasar Input Output, Operasi.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {
6 | "slideshow": {
7 | "slide_type": "slide"
8 | }
9 | },
10 | "source": [
11 | "# Tipe data, Variable dan operasi dasar\n",
12 | "klik untuk [Open in colab](https://colab.research.google.com/github/sykrn/py-dts/blob/master/Modul%202%20-%20Tipe%20Data%2C%20Variabel%2C%20Dasar%20Input%20Output%2C%20Operasi.ipynb) "
13 | ]
14 | },
15 | {
16 | "cell_type": "markdown",
17 | "metadata": {
18 | "slideshow": {
19 | "slide_type": "slide"
20 | }
21 | },
22 | "source": [
23 | "## Luaran pembelajaran\n",
24 | "\n",
25 | "- tipe data dan metode dasar untuk memformat, mengkonversi, input dan output data;\n",
26 | "- operator;\n",
27 | "- variabel."
28 | ]
29 | },
30 | {
31 | "cell_type": "markdown",
32 | "metadata": {
33 | "slideshow": {
34 | "slide_type": "slide"
35 | }
36 | },
37 | "source": [
38 | "# 2.1 Program Pertama\n",
39 | "\n",
40 | "- mengenal fungsi `print()`;\n",
41 | "- tanda kurung buka;\n",
42 | "- tanda kutip;\n",
43 | "- kalimat 1 baris: `Hello, World!`;\n",
44 | "- fungsi beberapa tanda kutip lain;\n",
45 | "- tanda kurung tutup."
46 | ]
47 | },
48 | {
49 | "cell_type": "code",
50 | "execution_count": null,
51 | "metadata": {
52 | "slideshow": {
53 | "slide_type": "fragment"
54 | }
55 | },
56 | "outputs": [],
57 | "source": [
58 | "print(\"Hello, World!!!!!!\")\n",
59 | "print(\"Goodbye World!!!\")\n"
60 | ]
61 | },
62 | {
63 | "cell_type": "markdown",
64 | "metadata": {
65 | "slideshow": {
66 | "slide_type": "slide"
67 | }
68 | },
69 | "source": [
70 | "## Lab\n",
71 | "- Cetak kalimat \"Hello, Python!\"\n",
72 | "- Cetak nama pertamamu\n",
73 | "- Cetak nama pertamamu tanpa petik\n",
74 | "- apakah ada bedanya double quote \"\" dan single quote ' ?"
75 | ]
76 | },
77 | {
78 | "cell_type": "code",
79 | "execution_count": null,
80 | "metadata": {
81 | "scrolled": true,
82 | "slideshow": {
83 | "slide_type": "fragment"
84 | }
85 | },
86 | "outputs": [],
87 | "source": [
88 | "print(\"Hello, Python!\")\n",
89 | "print(\"Petik satu atau dua\")\n",
90 | "print('Petik satu atau dua')\n"
91 | ]
92 | },
93 | {
94 | "cell_type": "markdown",
95 | "metadata": {
96 | "slideshow": {
97 | "slide_type": "slide"
98 | }
99 | },
100 | "source": [
101 | "## Formatting dengan Special Character\n",
102 | "- `\\` = karakter spesial \"escaping nature\"\n",
103 | "\n",
104 | "- `\\n` = untuk enter\n",
105 | "\n",
106 | "- `\\` = escaping karakter\n",
107 | "\n",
108 | "```python\n",
109 | "print() = berarti line kosong\n",
110 | "```\n",
111 | "\n",
112 | "Tidak boleh ada 2 perintah dalam 1 baris\n",
113 | "```python\n",
114 | "print(\"nama depan\") print (\"nama belakang\")\n",
115 | "```"
116 | ]
117 | },
118 | {
119 | "cell_type": "code",
120 | "execution_count": null,
121 | "metadata": {
122 | "scrolled": true,
123 | "slideshow": {
124 | "slide_type": "subslide"
125 | }
126 | },
127 | "outputs": [],
128 | "source": [
129 | "print(\"seketika langit menjadi gelap\\nkemudian hujan turun dengan deras.\")\n",
130 | "print()\n",
131 | "print(\"ibu memasak di dapur\\ndan kakak menyapu di halaman.\")\n",
132 | " "
133 | ]
134 | },
135 | {
136 | "cell_type": "code",
137 | "execution_count": null,
138 | "metadata": {
139 | "cell_style": "split",
140 | "slideshow": {
141 | "slide_type": "fragment"
142 | }
143 | },
144 | "outputs": [],
145 | "source": [
146 | "print(\"\\\"\")\n"
147 | ]
148 | },
149 | {
150 | "cell_type": "code",
151 | "execution_count": null,
152 | "metadata": {
153 | "cell_style": "split",
154 | "scrolled": false,
155 | "slideshow": {
156 | "slide_type": "fragment"
157 | }
158 | },
159 | "outputs": [],
160 | "source": [
161 | "print(\"\\\\\")\n"
162 | ]
163 | },
164 | {
165 | "cell_type": "code",
166 | "execution_count": null,
167 | "metadata": {
168 | "slideshow": {
169 | "slide_type": "fragment"
170 | }
171 | },
172 | "outputs": [],
173 | "source": [
174 | "# Dia mengatakan \"halo\"\n",
175 | "print(\"Dia mengatakan \\\"halo\\\"\")\n"
176 | ]
177 | },
178 | {
179 | "cell_type": "markdown",
180 | "metadata": {
181 | "slideshow": {
182 | "slide_type": "subslide"
183 | }
184 | },
185 | "source": [
186 | "Beberapa kalimat dapat dipisahkan dengan koma"
187 | ]
188 | },
189 | {
190 | "cell_type": "code",
191 | "execution_count": null,
192 | "metadata": {
193 | "slideshow": {
194 | "slide_type": "fragment"
195 | }
196 | },
197 | "outputs": [],
198 | "source": [
199 | "print(\"The itsy bitsy spider.\" , \"climbed up.\" , \"the waterspout.\")\n",
200 | " "
201 | ]
202 | },
203 | {
204 | "cell_type": "code",
205 | "execution_count": null,
206 | "metadata": {
207 | "slideshow": {
208 | "slide_type": "fragment"
209 | }
210 | },
211 | "outputs": [],
212 | "source": [
213 | "print(\"My name is\", \"Python.\")\n",
214 | "print(\"Monty Python.\")\n"
215 | ]
216 | },
217 | {
218 | "cell_type": "markdown",
219 | "metadata": {
220 | "slideshow": {
221 | "slide_type": "subslide"
222 | }
223 | },
224 | "source": [
225 | "```end=\" \"``` digunakan untuk meletakkan argumen setelah argumen pertama"
226 | ]
227 | },
228 | {
229 | "cell_type": "code",
230 | "execution_count": null,
231 | "metadata": {},
232 | "outputs": [],
233 | "source": [
234 | "print(\"My name is\", \"Python.\", end=\" \")\n",
235 | "print(\"Monty Python.\")\n"
236 | ]
237 | },
238 | {
239 | "cell_type": "code",
240 | "execution_count": null,
241 | "metadata": {},
242 | "outputs": [],
243 | "source": [
244 | "print(\"My name is \", end=\" ## \")\n",
245 | "print(\"Monty Python.\")\n"
246 | ]
247 | },
248 | {
249 | "cell_type": "markdown",
250 | "metadata": {
251 | "slideshow": {
252 | "slide_type": "subslide"
253 | }
254 | },
255 | "source": [
256 | "```sep=\" \" ``` digunakan untuk memisahkan antar argumen dengan string kosong atau karakter lain"
257 | ]
258 | },
259 | {
260 | "cell_type": "code",
261 | "execution_count": null,
262 | "metadata": {},
263 | "outputs": [],
264 | "source": [
265 | "print(\"My\", \"name\", \"is\", \"Monty\", \"Python.\", sep=\"-\")"
266 | ]
267 | },
268 | {
269 | "cell_type": "code",
270 | "execution_count": null,
271 | "metadata": {},
272 | "outputs": [],
273 | "source": [
274 | "print(\"My\", \"name\", \"is\", sep=\"_\", end=\"*\")\n",
275 | "print(\"Monty\", \"Python.\", sep=\"*\", end=\"*\\n\")\n",
276 | "print(\"Digital\", \"Talent\", \"Dahsyat\", sep=\"_\", end=\"*\")\n",
277 | "print(\"Guntur\", \"Budi.\", sep=\"*\", end=\"*\\n\")"
278 | ]
279 | },
280 | {
281 | "cell_type": "markdown",
282 | "metadata": {
283 | "slideshow": {
284 | "slide_type": "subslide"
285 | }
286 | },
287 | "source": [
288 | "## Lab\n",
289 | "\n",
290 | "Buatlah Program untuk menghasilkan output:\n",
291 | "`Programming***Essentials***in...Python`"
292 | ]
293 | },
294 | {
295 | "cell_type": "code",
296 | "execution_count": null,
297 | "metadata": {
298 | "slideshow": {
299 | "slide_type": "fragment"
300 | }
301 | },
302 | "outputs": [],
303 | "source": [
304 | "print(\"Programming\",\"Essentials\",\"in\",sep=\"***\",end=\"...\")\n",
305 | "print(\"Python\")\n"
306 | ]
307 | },
308 | {
309 | "cell_type": "markdown",
310 | "metadata": {
311 | "slideshow": {
312 | "slide_type": "subslide"
313 | }
314 | },
315 | "source": [
316 | "## Lab\n",
317 | "\n",
318 | "Buatlah program dengan output sebagai berikut:\n",
319 | "```\n",
320 | " *\n",
321 | " * *\n",
322 | " * *\n",
323 | " * *\n",
324 | "*** ***\n",
325 | " * *\n",
326 | " * *\n",
327 | " ***** \n",
328 | "```"
329 | ]
330 | },
331 | {
332 | "cell_type": "code",
333 | "execution_count": null,
334 | "metadata": {
335 | "slideshow": {
336 | "slide_type": "subslide"
337 | }
338 | },
339 | "outputs": [],
340 | "source": [
341 | "print(\" *\\n * *\\n * *\\n * *\\n*** ***\\n * *\\n * *\\n *****\\n\"*2)\n"
342 | ]
343 | },
344 | {
345 | "cell_type": "code",
346 | "execution_count": null,
347 | "metadata": {
348 | "slideshow": {
349 | "slide_type": "subslide"
350 | }
351 | },
352 | "outputs": [],
353 | "source": [
354 | "print(\" * \"*2)\n",
355 | "print(\" * * \"*2)\n",
356 | "print(\" * * \"*2)\n",
357 | "print(\" * * \"*2)\n",
358 | "print(\"*** ***\"*2)\n",
359 | "print(\" * * \"*2)\n",
360 | "print(\" * * \"*2)\n",
361 | "print(\" ***** \"*2)\n"
362 | ]
363 | },
364 | {
365 | "cell_type": "markdown",
366 | "metadata": {
367 | "slideshow": {
368 | "slide_type": "slide"
369 | }
370 | },
371 | "source": [
372 | "## 2.2 Literals\n",
373 | "literal merupakan notasi untuk mensimbolkan nilai, dapat berupa string, boolean maupun angka (integer dan float)"
374 | ]
375 | },
376 | {
377 | "cell_type": "code",
378 | "execution_count": null,
379 | "metadata": {
380 | "slideshow": {
381 | "slide_type": "fragment"
382 | }
383 | },
384 | "outputs": [],
385 | "source": [
386 | "# hasil output akan terlihat sama, namun nilai tersebut tersimpan berbeda dalam memori komputer\n",
387 | "print(\"2\")\n",
388 | "print(2)\n",
389 | "\n",
390 | "print(type(\"2\"))\n",
391 | "print(type(2))\n"
392 | ]
393 | },
394 | {
395 | "cell_type": "markdown",
396 | "metadata": {
397 | "slideshow": {
398 | "slide_type": "subslide"
399 | }
400 | },
401 | "source": [
402 | "## Integers vs Floats\n"
403 | ]
404 | },
405 | {
406 | "cell_type": "code",
407 | "execution_count": null,
408 | "metadata": {
409 | "slideshow": {
410 | "slide_type": "fragment"
411 | }
412 | },
413 | "outputs": [],
414 | "source": [
415 | "print(5, \"mempunyai tipe\", type(5))\n",
416 | "\n",
417 | "print(5.0, \"mempunyai tipe\", type(5.0))\n"
418 | ]
419 | },
420 | {
421 | "cell_type": "markdown",
422 | "metadata": {
423 | "slideshow": {
424 | "slide_type": "subslide"
425 | }
426 | },
427 | "source": [
428 | "\n",
429 | "## Penulisan Float dan Integer\n",
430 | "Python versi 3 membolehkan pemisahan digit integer dengan underscore \"_\"\n",
431 | "agar mudah dibaca\n",
432 | "```python\n",
433 | "print (10_000_000)```\n",
434 | "\n",
435 | "Float dipisahkan dengan .(titik) bukan ,(koma)\n",
436 | "cara penulisan float bisa 3 cara\n",
437 | "\n",
438 | "- 4.0\n",
439 | "- .4 (terbaca nol koma 4)\n",
440 | "- 4. (terbaca 4 koma nol)\n",
441 | "\n",
442 | "> 3e08 berarti $ 3 x 10 ^ 8 $ \n",
443 | "3e-08 berarti $ 3 x 10 ^ {-8} $\n"
444 | ]
445 | },
446 | {
447 | "cell_type": "code",
448 | "execution_count": null,
449 | "metadata": {
450 | "slideshow": {
451 | "slide_type": "fragment"
452 | }
453 | },
454 | "outputs": [],
455 | "source": [
456 | "print (0.000000003)\n",
457 | "print (3e-8)\n"
458 | ]
459 | },
460 | {
461 | "cell_type": "markdown",
462 | "metadata": {
463 | "slideshow": {
464 | "slide_type": "subslide"
465 | }
466 | },
467 | "source": [
468 | "## String\n",
469 | "\n",
470 | "Buatlah program untuk menghasilkan output `I'm Monty Python`"
471 | ]
472 | },
473 | {
474 | "cell_type": "code",
475 | "execution_count": null,
476 | "metadata": {
477 | "slideshow": {
478 | "slide_type": "fragment"
479 | }
480 | },
481 | "outputs": [],
482 | "source": [
483 | "print(\"I'm Monty Python\")\n",
484 | "print(\"Jum'at\")\n",
485 | "print('\"Saya berpendapat python itu mudah\", kata Monty')\n",
486 | "print(\"1.5\")\n",
487 | "print(\"1000\")\n"
488 | ]
489 | },
490 | {
491 | "cell_type": "code",
492 | "execution_count": null,
493 | "metadata": {
494 | "slideshow": {
495 | "slide_type": "fragment"
496 | }
497 | },
498 | "outputs": [],
499 | "source": [
500 | "#string kosong pun juga bernilai string\n",
501 | "print(\"\")\n",
502 | "print('')\n"
503 | ]
504 | },
505 | {
506 | "cell_type": "markdown",
507 | "metadata": {
508 | "slideshow": {
509 | "slide_type": "subslide"
510 | }
511 | },
512 | "source": [
513 | "## Booelan\n",
514 | "Logika benar salah, 1 bernilai benar (True) dan 0 bernilai salah (False)"
515 | ]
516 | },
517 | {
518 | "cell_type": "code",
519 | "execution_count": null,
520 | "metadata": {
521 | "slideshow": {
522 | "slide_type": "fragment"
523 | }
524 | },
525 | "outputs": [],
526 | "source": [
527 | "print(True)\n",
528 | "print(False)\n",
529 | "print (3>0)\n",
530 | "print (0>3)"
531 | ]
532 | },
533 | {
534 | "cell_type": "markdown",
535 | "metadata": {
536 | "slideshow": {
537 | "slide_type": "subslide"
538 | }
539 | },
540 | "source": [
541 | "## None"
542 | ]
543 | },
544 | {
545 | "cell_type": "code",
546 | "execution_count": null,
547 | "metadata": {
548 | "slideshow": {
549 | "slide_type": "fragment"
550 | }
551 | },
552 | "outputs": [],
553 | "source": [
554 | "print(None)"
555 | ]
556 | },
557 | {
558 | "cell_type": "markdown",
559 | "metadata": {
560 | "slideshow": {
561 | "slide_type": "subslide"
562 | }
563 | },
564 | "source": [
565 | "## Lab\n",
566 | "Buat output seperti ini dalam satu line
\n",
567 | "`\"I'm\"`
\n",
568 | "`\"\"learning\"\"`
\n",
569 | "`\"\"\"Python\"\"\"`"
570 | ]
571 | },
572 | {
573 | "cell_type": "code",
574 | "execution_count": null,
575 | "metadata": {
576 | "slideshow": {
577 | "slide_type": "fragment"
578 | }
579 | },
580 | "outputs": [],
581 | "source": [
582 | "print('\"I\\'m\"\\n\"\"learning\"\"\\n\"\"\"Python\"\"\"')\n",
583 | "\n",
584 | "print(\"\"\"\n",
585 | "\"I'm\"\n",
586 | "\"\"learning\"\"\n",
587 | "\\\"\"\"Python\"\"\\\"\n",
588 | "\"\"\")"
589 | ]
590 | },
591 | {
592 | "cell_type": "markdown",
593 | "metadata": {
594 | "slideshow": {
595 | "slide_type": "slide"
596 | }
597 | },
598 | "source": [
599 | "# 2.3 Operator"
600 | ]
601 | },
602 | {
603 | "cell_type": "markdown",
604 | "metadata": {
605 | "slideshow": {
606 | "slide_type": "fragment"
607 | }
608 | },
609 | "source": [
610 | "### Operator Aritmetika\n",
611 | "\n",
612 | "| Operator | Arti | Contoh |\n",
613 | "|----------|--------------------------------------------------------------------------------------------------|--------------------------|\n",
614 | "| + | Penambahan | x + y |\n",
615 | "| - | Pengurangan | x - y |\n",
616 | "| * | Perkalian | x * y |\n",
617 | "| / | Pembagian | x / y |\n",
618 | "| % | Modulo - Sisa Pembagian | x % y (sisa pembagian of x/y) |\n",
619 | "| // | Pembagian dan dibulatkan ke bawah | x // y |\n",
620 | "| ** | Eksponen - Pangkat | x**y (x pangkat y) |"
621 | ]
622 | },
623 | {
624 | "cell_type": "code",
625 | "execution_count": null,
626 | "metadata": {
627 | "slideshow": {
628 | "slide_type": "subslide"
629 | }
630 | },
631 | "outputs": [],
632 | "source": [
633 | "#eksponen/pangkat\n",
634 | "print(2 ** 3)\n",
635 | "print(2 ** 3.)\n",
636 | "print(2. ** 3)\n",
637 | "print(2. ** 3.)\n"
638 | ]
639 | },
640 | {
641 | "cell_type": "code",
642 | "execution_count": null,
643 | "metadata": {
644 | "slideshow": {
645 | "slide_type": "fragment"
646 | }
647 | },
648 | "outputs": [],
649 | "source": [
650 | "#pembagian\n",
651 | "print(6 / 3)\n",
652 | "print(6 / 3.)\n",
653 | "print(6. / 3)\n",
654 | "print(6. / 3.)\n"
655 | ]
656 | },
657 | {
658 | "cell_type": "code",
659 | "execution_count": null,
660 | "metadata": {
661 | "slideshow": {
662 | "slide_type": "subslide"
663 | }
664 | },
665 | "outputs": [],
666 | "source": [
667 | "#pembagian dengan pembulatan ke bawah\n",
668 | "print(6 // 3)\n",
669 | "print(6 // 3.)\n",
670 | "print(6. // 3)\n",
671 | "print(6. // 3.)\n"
672 | ]
673 | },
674 | {
675 | "cell_type": "code",
676 | "execution_count": null,
677 | "metadata": {
678 | "slideshow": {
679 | "slide_type": "fragment"
680 | }
681 | },
682 | "outputs": [],
683 | "source": [
684 | "print(6 // 4)\n",
685 | "print(6. // 4)\n",
686 | "\n",
687 | "print(6 / 4)\n",
688 | "print(6. / 4)\n",
689 | "\n",
690 | "#Penting ! pembulatan selalu ke nilai bawahnya\n"
691 | ]
692 | },
693 | {
694 | "cell_type": "code",
695 | "execution_count": null,
696 | "metadata": {
697 | "slideshow": {
698 | "slide_type": "fragment"
699 | }
700 | },
701 | "outputs": [],
702 | "source": [
703 | "print(-6 // 4)\n",
704 | "print(6. // -4)\n"
705 | ]
706 | },
707 | {
708 | "cell_type": "code",
709 | "execution_count": null,
710 | "metadata": {
711 | "slideshow": {
712 | "slide_type": "subslide"
713 | }
714 | },
715 | "outputs": [],
716 | "source": [
717 | "#modulo/sisa bagi\n",
718 | "print(14 % 4)\n"
719 | ]
720 | },
721 | {
722 | "cell_type": "code",
723 | "execution_count": null,
724 | "metadata": {
725 | "slideshow": {
726 | "slide_type": "fragment"
727 | }
728 | },
729 | "outputs": [],
730 | "source": [
731 | "print(-4 + 4)\n",
732 | "print(-4. + 8)\n"
733 | ]
734 | },
735 | {
736 | "cell_type": "markdown",
737 | "metadata": {
738 | "slideshow": {
739 | "slide_type": "subslide"
740 | }
741 | },
742 | "source": [
743 | "### Urutan Operator"
744 | ]
745 | },
746 | {
747 | "cell_type": "code",
748 | "execution_count": null,
749 | "metadata": {
750 | "slideshow": {
751 | "slide_type": "fragment"
752 | }
753 | },
754 | "outputs": [],
755 | "source": [
756 | "#perkalian lebih didahulukan dari penambahan\n",
757 | "2 + 3 * 5\n"
758 | ]
759 | },
760 | {
761 | "cell_type": "code",
762 | "execution_count": null,
763 | "metadata": {
764 | "slideshow": {
765 | "slide_type": "fragment"
766 | }
767 | },
768 | "outputs": [],
769 | "source": [
770 | "#pengerjaan dari kiri ke kanan\n",
771 | "print(9 % 6 % 2)\n"
772 | ]
773 | },
774 | {
775 | "cell_type": "code",
776 | "execution_count": null,
777 | "metadata": {
778 | "slideshow": {
779 | "slide_type": "fragment"
780 | }
781 | },
782 | "outputs": [],
783 | "source": [
784 | "#pengerjaan dari kanan ke kiri\n",
785 | "print(2 ** 2 ** 3)\n"
786 | ]
787 | },
788 | {
789 | "cell_type": "markdown",
790 | "metadata": {
791 | "slideshow": {
792 | "slide_type": "subslide"
793 | }
794 | },
795 | "source": [
796 | "| Prioritas| Operator | ket |\n",
797 | "|----------|----------|--------|\n",
798 | "| 1 | +, - | unary |\n",
799 | "| 2 | ** | |\n",
800 | "| 3 | *, /, % | |\n",
801 | "| 4 | +, - | binary |"
802 | ]
803 | },
804 | {
805 | "cell_type": "code",
806 | "execution_count": null,
807 | "metadata": {
808 | "slideshow": {
809 | "slide_type": "fragment"
810 | }
811 | },
812 | "outputs": [],
813 | "source": [
814 | "print((5 * ((25 % 13) + 100) / (2 * 13)) // 2)\n"
815 | ]
816 | },
817 | {
818 | "cell_type": "markdown",
819 | "metadata": {
820 | "slideshow": {
821 | "slide_type": "subslide"
822 | }
823 | },
824 | "source": [
825 | "### Latihan\n",
826 | "\n",
827 | "`print((2 ** 4), (2 * 4.), (2 * 4))`
\n",
828 | "`print((-2 / 4), (2 / 4), (2 // 4), (-2 // 4))`
\n",
829 | "`print((2 % -4), (2 % 4), (2 ** 3 ** 2))`
"
830 | ]
831 | },
832 | {
833 | "cell_type": "markdown",
834 | "metadata": {
835 | "slideshow": {
836 | "slide_type": "slide"
837 | }
838 | },
839 | "source": [
840 | "# 2.4 Variabel\n",
841 | "- Apa itu variabel?\n",
842 | "- Bagaimana Aturan Penamaannya?\n"
843 | ]
844 | },
845 | {
846 | "cell_type": "code",
847 | "execution_count": null,
848 | "metadata": {
849 | "slideshow": {
850 | "slide_type": "fragment"
851 | }
852 | },
853 | "outputs": [],
854 | "source": [
855 | "# kamu bisa menaruh tipe data apapun dalam variabel\n",
856 | "var = 1 # bukan operasi matematika, namun operasi assignment i.e., var <-- 1\n",
857 | "print(var)\n"
858 | ]
859 | },
860 | {
861 | "cell_type": "markdown",
862 | "metadata": {
863 | "slideshow": {
864 | "slide_type": "fragment"
865 | }
866 | },
867 | "source": [
868 | "- baris pertama membuat variabel dengan nama `var`, dan diisi dengan nilai `1`.\n",
869 | "- baris kedua mencetak nilai dalam variabel ke dalam console"
870 | ]
871 | },
872 | {
873 | "cell_type": "code",
874 | "execution_count": null,
875 | "metadata": {
876 | "slideshow": {
877 | "slide_type": "subslide"
878 | }
879 | },
880 | "outputs": [],
881 | "source": [
882 | "var = 1\n",
883 | "saldo = 1000.0\n",
884 | "namaKlien = 'John Doe'\n",
885 | "print(var, saldo, namaKlien)\n",
886 | "print(var)\n"
887 | ]
888 | },
889 | {
890 | "cell_type": "code",
891 | "execution_count": null,
892 | "metadata": {
893 | "slideshow": {
894 | "slide_type": "fragment"
895 | }
896 | },
897 | "outputs": [],
898 | "source": [
899 | "#case sensitive, huruf besar kecil perlu diperhatikan!\n",
900 | "var = 1\n",
901 | "print(Var) "
902 | ]
903 | },
904 | {
905 | "cell_type": "code",
906 | "execution_count": null,
907 | "metadata": {
908 | "slideshow": {
909 | "slide_type": "fragment"
910 | }
911 | },
912 | "outputs": [],
913 | "source": [
914 | "#tanda '+' bisa digunakan untuk kontatinasi untuk type string\n",
915 | "var = \"2019\"\n",
916 | "print(\"Digital talent: \" + var)"
917 | ]
918 | },
919 | {
920 | "cell_type": "code",
921 | "execution_count": null,
922 | "metadata": {
923 | "slideshow": {
924 | "slide_type": "subslide"
925 | }
926 | },
927 | "outputs": [],
928 | "source": [
929 | "#menetapkan nilai baru ke dalam variabel yang telah ada \n",
930 | "#menugaskan variabel\n",
931 | "\n",
932 | "var = 1\n",
933 | "print(var)\n",
934 | "var = var + 1\n",
935 | "print(var)"
936 | ]
937 | },
938 | {
939 | "cell_type": "code",
940 | "execution_count": null,
941 | "metadata": {
942 | "slideshow": {
943 | "slide_type": "fragment"
944 | }
945 | },
946 | "outputs": [],
947 | "source": [
948 | "var = 100\n",
949 | "var = 200 + 300\n",
950 | "print(var)"
951 | ]
952 | },
953 | {
954 | "cell_type": "markdown",
955 | "metadata": {
956 | "slideshow": {
957 | "slide_type": "subslide"
958 | }
959 | },
960 | "source": [
961 | "### Latihan\n",
962 | "Tulis rumus ini dalam kode program:
$c=\\sqrt{a^2+b^2}$"
963 | ]
964 | },
965 | {
966 | "cell_type": "code",
967 | "execution_count": null,
968 | "metadata": {
969 | "slideshow": {
970 | "slide_type": "fragment"
971 | }
972 | },
973 | "outputs": [],
974 | "source": [
975 | "a = 3.0\n",
976 | "b = 4.0\n",
977 | "c = (a ** 2 + b ** 2) ** 0.5\n",
978 | "print(\"c =\", c)"
979 | ]
980 | },
981 | {
982 | "cell_type": "markdown",
983 | "metadata": {
984 | "slideshow": {
985 | "slide_type": "subslide"
986 | }
987 | },
988 | "source": [
989 | "### Lab\n",
990 | "\n",
991 | "Cerita Pendek: \n",
992 | "\n",
993 | "Suatu waktu di kebun apel, Guntur memiliki 3 apel, Icha memiliki 5 apel dan Ratna memiliki 6 Apel. mereka sangat bahagia dan hidup lama. selesai.\n",
994 | "\n",
995 | "Tugas Anda\n",
996 | "- buat variabe : `Guntur`, `Icha` dan `Ratna`\n",
997 | "- isi nilai sesuai dengan jumlah apel yang mereka miliki\n",
998 | "- cetak nama variabel dan jumlah apel setiap variabel dalam 1 baris, pisahkan dengan koma\n",
999 | "- buat variabel baru dengan nama `totalApel` yang berisi penjumlahan seluruh apel yang mereka miliki\n",
1000 | "- coba otak atik code dengan membuat variable baru, diisi dengan nilai lain, dan dihitung dengan operator aritmetik lainnya\n"
1001 | ]
1002 | },
1003 | {
1004 | "cell_type": "code",
1005 | "execution_count": null,
1006 | "metadata": {
1007 | "slideshow": {
1008 | "slide_type": "subslide"
1009 | }
1010 | },
1011 | "outputs": [],
1012 | "source": [
1013 | "Guntur = 3\n",
1014 | "Icha = 5\n",
1015 | "Ratna = 6\n",
1016 | "\n",
1017 | "print(\"Apel milik Guntur\",Guntur)\n",
1018 | "print(\"Apel milik Guntur\",Icha)\n",
1019 | "print(\"Apel milik Guntur\",Ratna)\n",
1020 | "\n",
1021 | "totalApel = Guntur + Icha + Ratna\n",
1022 | "print(\"Total number of apples: \" , totalApel)"
1023 | ]
1024 | },
1025 | {
1026 | "cell_type": "code",
1027 | "execution_count": null,
1028 | "metadata": {
1029 | "slideshow": {
1030 | "slide_type": "subslide"
1031 | }
1032 | },
1033 | "outputs": [],
1034 | "source": [
1035 | "#Jalan Pintas operator\n",
1036 | "\n",
1037 | "sheep = 5\n",
1038 | "sheep = sheep + 1\n",
1039 | "print(sheep)\n",
1040 | "\n",
1041 | "sheep += 3\n",
1042 | "print(sheep)\n",
1043 | "\n",
1044 | "sheep *= 2\n",
1045 | "print(sheep)"
1046 | ]
1047 | },
1048 | {
1049 | "cell_type": "markdown",
1050 | "metadata": {
1051 | "slideshow": {
1052 | "slide_type": "subslide"
1053 | }
1054 | },
1055 | "source": [
1056 | "### Lab\n",
1057 | "\n",
1058 | "Mil dan kilometer adalah satuan panjang\n",
1059 | "\n",
1060 | "1 mil memiliki panjang sekitar 1.61 kilometer, buatlah program konversi di bawah ini\n",
1061 | "- mil ke kilometer;\n",
1062 | "- kilometer to mil.\n",
1063 | "jangan ganti apapun terhadap kode yang sudah ada. tulis kodemu pada tanda ###, kemudian hapus tanda tersebut. Uji kode Anda dengan data yang kami sajikan dalam source code\n"
1064 | ]
1065 | },
1066 | {
1067 | "cell_type": "markdown",
1068 | "metadata": {
1069 | "slideshow": {
1070 | "slide_type": "subslide"
1071 | }
1072 | },
1073 | "source": [
1074 | "Kode:\n",
1075 | "```python\n",
1076 | "kilometer = 12.25\n",
1077 | "mil = 7.38\n",
1078 | "\n",
1079 | "mil_ke_kilometer = ###\n",
1080 | "kilometer_ke_mil = ###\n",
1081 | "\n",
1082 | "print(mil, \"1 mil adalah\", round(miles_to_kilometers, 2), \"kilometer\")\n",
1083 | "print(kilometer, \"1 kilometer adalah\", round(kilometers_to_miles, 2), \"mil\")\n",
1084 | "```"
1085 | ]
1086 | },
1087 | {
1088 | "cell_type": "code",
1089 | "execution_count": null,
1090 | "metadata": {
1091 | "slideshow": {
1092 | "slide_type": "subslide"
1093 | }
1094 | },
1095 | "outputs": [],
1096 | "source": [
1097 | "kilometer = 12.25\n",
1098 | "mil = 7.61\n",
1099 | "\n",
1100 | "mil_ke_kilometer = mil * 1.61\n",
1101 | "kilometer_ke_mil = kilometer / 1.61\n",
1102 | "\n",
1103 | "print(mil, \"mil adalah\", round(mil_ke_kilometer, 2), \"kilometer\")\n",
1104 | "print(kilometer, \"kilometer adalah\", round(kilometer_ke_mil, 2), \"mil\")"
1105 | ]
1106 | },
1107 | {
1108 | "cell_type": "markdown",
1109 | "metadata": {
1110 | "slideshow": {
1111 | "slide_type": "subslide"
1112 | }
1113 | },
1114 | "source": [
1115 | "### Lab\n",
1116 | "\n",
1117 | "Skenario\n",
1118 | "lihatlah kode dalam editor, nilai tersebut termasuk tipe float, letakkan nilai tersebut dalam variabel x, dan print variabel tersebut dalam variabel y. Tugasmu adalah melengkapi kode di bawah ini untk menyelesaikan persamaan di bawah\n",
1119 | "\n",
1120 | "$3x^3 - 2x^2 + 3x - 1$\n",
1121 | "\n",
1122 | "Hasil harus disimpan dalam variabel y.\n",
1123 | "ingat bahwa aljabar klasik sering menghilangkan operator perkalian, kamu harus menggunakannya secara eksplisit. Ingat bagaimana cara mengubah tipe data untuk memastikan bahwa x bertipe float.\n",
1124 | "\n",
1125 | "usahakan kodemu mudah dibaca, uji kode dengan data yang telah kami berikan.\n",
1126 | "\n",
1127 | "```python\n",
1128 | "x = # hardcode your test data here\n",
1129 | "x = float(x)\n",
1130 | "# tulis kodemu disini\n",
1131 | "print(\"y =\", y)\n",
1132 | "```\n",
1133 | "\n",
1134 | "Test Data:\n",
1135 | "```python\n",
1136 | "#input\n",
1137 | "x = 0\n",
1138 | "x = 1\n",
1139 | "x = -1\n",
1140 | "\n",
1141 | "#output\n",
1142 | "y = -1.0\n",
1143 | "y = 3.0\n",
1144 | "y = -9.0\n",
1145 | "```"
1146 | ]
1147 | },
1148 | {
1149 | "cell_type": "code",
1150 | "execution_count": null,
1151 | "metadata": {
1152 | "slideshow": {
1153 | "slide_type": "subslide"
1154 | }
1155 | },
1156 | "outputs": [],
1157 | "source": [
1158 | "x = -1\n",
1159 | "x = float(x)\n",
1160 | "y = 3*x**3 - 2*x**2 + 3*x -1\n",
1161 | "print(\"y =\", y)"
1162 | ]
1163 | },
1164 | {
1165 | "cell_type": "markdown",
1166 | "metadata": {
1167 | "slideshow": {
1168 | "slide_type": "subslide"
1169 | }
1170 | },
1171 | "source": [
1172 | "### Exercise\n",
1173 | "\n",
1174 | "Apa outputnya?\n",
1175 | "```python\n",
1176 | "var = 2\n",
1177 | "var = 3\n",
1178 | "print(var)\n",
1179 | "```\n",
1180 | "\n",
1181 | "Nama variabel mana yang ilegal?\n",
1182 | "```python\n",
1183 | "my_var\n",
1184 | "m\n",
1185 | "101\n",
1186 | "averylongvariablename\n",
1187 | "m101\n",
1188 | "m 101\n",
1189 | "Del\n",
1190 | "del\n",
1191 | "```\n",
1192 | "\n",
1193 | "Apa Outputnya?\n",
1194 | "```python\n",
1195 | "a = '1'\n",
1196 | "b = \"1\"\n",
1197 | "print(a + b)\n",
1198 | "```\n",
1199 | "\n",
1200 | "Apa outputnya?\n",
1201 | "\n",
1202 | "```python\n",
1203 | "a = 6\n",
1204 | "b = 3\n",
1205 | "a /= 2 * b\n",
1206 | "print(a)\n",
1207 | "```"
1208 | ]
1209 | },
1210 | {
1211 | "cell_type": "markdown",
1212 | "metadata": {
1213 | "slideshow": {
1214 | "slide_type": "slide"
1215 | }
1216 | },
1217 | "source": [
1218 | "# 2.5 Comments\n",
1219 | "Latihan: mana yang seharusnya menjadi komentar, mana yang tidak"
1220 | ]
1221 | },
1222 | {
1223 | "cell_type": "code",
1224 | "execution_count": null,
1225 | "metadata": {
1226 | "slideshow": {
1227 | "slide_type": "fragment"
1228 | }
1229 | },
1230 | "outputs": [],
1231 | "source": [
1232 | "#this program computes the number of seconds in a given number of hours\n",
1233 | "# this program has been written two days ago\n",
1234 | "\n",
1235 | "a = 2 # number of hours\n",
1236 | "seconds = 3600 # number of seconds in 1 hour\n",
1237 | "\n",
1238 | "print(\"Hours: \", a) #printing the number of hours\n",
1239 | "# print(\"Seconds in Hours: \", a * seconds) # printing the number of seconds in a given number of hours\n",
1240 | "\n",
1241 | "#here we should also print \"Goodbye\", but a programmer didn't have time to write any code\n",
1242 | "#this is the end of the program that computes the number of seconds in 3 hour\n"
1243 | ]
1244 | },
1245 | {
1246 | "cell_type": "markdown",
1247 | "metadata": {
1248 | "slideshow": {
1249 | "slide_type": "slide"
1250 | }
1251 | },
1252 | "source": [
1253 | "# 2.6 How to talk to a computer \n",
1254 | "katakunci `input()`
\n",
1255 | "hasil dari fungsi `input()` adalah string.
\n",
1256 | "Tidak bisa langsung dikenakan ke operasi aritmetika"
1257 | ]
1258 | },
1259 | {
1260 | "cell_type": "code",
1261 | "execution_count": null,
1262 | "metadata": {
1263 | "slideshow": {
1264 | "slide_type": "fragment"
1265 | }
1266 | },
1267 | "outputs": [],
1268 | "source": [
1269 | "print(\"Tell me anything...\")\n",
1270 | "anything = input()\n",
1271 | "print(\"Hmm...\", anything, \"... Really?\")\n"
1272 | ]
1273 | },
1274 | {
1275 | "cell_type": "code",
1276 | "execution_count": null,
1277 | "metadata": {
1278 | "slideshow": {
1279 | "slide_type": "fragment"
1280 | }
1281 | },
1282 | "outputs": [],
1283 | "source": [
1284 | "angka = input(\"Masukkan Angka...\")\n",
1285 | "print(\"Pangkat duanya adalah\", angka*2)\n"
1286 | ]
1287 | },
1288 | {
1289 | "cell_type": "markdown",
1290 | "metadata": {
1291 | "slideshow": {
1292 | "slide_type": "subslide"
1293 | }
1294 | },
1295 | "source": [
1296 | "### type casting"
1297 | ]
1298 | },
1299 | {
1300 | "cell_type": "code",
1301 | "execution_count": null,
1302 | "metadata": {
1303 | "slideshow": {
1304 | "slide_type": "fragment"
1305 | }
1306 | },
1307 | "outputs": [],
1308 | "source": [
1309 | "angka = float(input(\"Masukkan Angka...\"))\n",
1310 | "print(\"Pangkat duanya adalah\", angka**2)\n"
1311 | ]
1312 | },
1313 | {
1314 | "cell_type": "code",
1315 | "execution_count": null,
1316 | "metadata": {
1317 | "slideshow": {
1318 | "slide_type": "fragment"
1319 | }
1320 | },
1321 | "outputs": [],
1322 | "source": [
1323 | "leg_a = float(input(\"Input first leg length: \"))\n",
1324 | "leg_b = float(input(\"Input second leg length: \"))\n",
1325 | "hypo = (leg_a**2 + leg_b**2) ** .5\n",
1326 | "print(\"Hypotenuse length is\", hypo)\n"
1327 | ]
1328 | },
1329 | {
1330 | "cell_type": "code",
1331 | "execution_count": null,
1332 | "metadata": {
1333 | "slideshow": {
1334 | "slide_type": "fragment"
1335 | }
1336 | },
1337 | "outputs": [],
1338 | "source": [
1339 | "fnam = input(\"May I have your first name, please? \")\n",
1340 | "lnam = input(\"May I have your last name, please? \")\n",
1341 | "print(\"Thank you.\")\n",
1342 | "print(\"\\nYour name is \" + fnam + \" \" + lnam + \".\")\n"
1343 | ]
1344 | },
1345 | {
1346 | "cell_type": "code",
1347 | "execution_count": null,
1348 | "metadata": {
1349 | "slideshow": {
1350 | "slide_type": "subslide"
1351 | }
1352 | },
1353 | "outputs": [],
1354 | "source": [
1355 | "#Replication\n",
1356 | "\n",
1357 | "print(\"+\" + 10 * \"-\" + \"+\")\n",
1358 | "print((\"|\" + \" \" * 10 + \"|\\n\") * 5, end=\"\")\n",
1359 | "print(\"+\" + 10 * \"-\" + \"+\")\n"
1360 | ]
1361 | },
1362 | {
1363 | "cell_type": "code",
1364 | "execution_count": null,
1365 | "metadata": {
1366 | "slideshow": {
1367 | "slide_type": "fragment"
1368 | }
1369 | },
1370 | "outputs": [],
1371 | "source": [
1372 | "leg_a = float(input(\"Input first leg length: \"))\n",
1373 | "leg_b = float(input(\"Input second leg length: \"))\n",
1374 | "print(\"Hypotenuse length is \" + str((leg_a**2 + leg_b**2) ** .5))\n"
1375 | ]
1376 | },
1377 | {
1378 | "cell_type": "markdown",
1379 | "metadata": {
1380 | "slideshow": {
1381 | "slide_type": "subslide"
1382 | }
1383 | },
1384 | "source": [
1385 | "### Lab\n",
1386 | "Coba utak atik perintah kode dibawah ini\n",
1387 | "``` python\n",
1388 | "# Masukkan nilai a dalam float\n",
1389 | "# Masukkan nilai b dalam float\n",
1390 | "\n",
1391 | "# hitung hasil penambahan disini\n",
1392 | "# hitung hasil pengurangan disini\n",
1393 | "# hitung hasil perkalian disini\n",
1394 | "# hitung hasil pembagian disini\n",
1395 | "\n",
1396 | "\n",
1397 | "print(\"\\nYeahhhh\")\n",
1398 | "```"
1399 | ]
1400 | },
1401 | {
1402 | "cell_type": "code",
1403 | "execution_count": null,
1404 | "metadata": {
1405 | "slideshow": {
1406 | "slide_type": "subslide"
1407 | }
1408 | },
1409 | "outputs": [],
1410 | "source": [
1411 | "a = float(input(\"Masukkan a = \"))\n",
1412 | "b = float(input(\"Masukkan b = \"))\n",
1413 | "\n",
1414 | "print(\"a+b = \",a+b)\n",
1415 | "print(\"a-b = \",a-b)\n",
1416 | "print(\"a*b = \",a*b)\n",
1417 | "print(\"a/b = \",a/b)\n",
1418 | "print(\"\\nYeahhhh!\")\n"
1419 | ]
1420 | },
1421 | {
1422 | "cell_type": "markdown",
1423 | "metadata": {
1424 | "slideshow": {
1425 | "slide_type": "subslide"
1426 | }
1427 | },
1428 | "source": [
1429 | "### Lab\n",
1430 | "Kerjakan rumus berikut:\n",
1431 | "\n",
1432 | "$$\\frac{1}{x+\\frac{1}{x+\\frac{1}{x+\\frac{1}{x}}}}$$\n",
1433 | "\n",
1434 | "input/output yang diharapkan\n",
1435 | "```python\n",
1436 | "x = 1\n",
1437 | "y = 0.6000000000000001\n",
1438 | "\n",
1439 | "x = 10\n",
1440 | "y = 0.09901951266867294\n",
1441 | "```"
1442 | ]
1443 | },
1444 | {
1445 | "cell_type": "code",
1446 | "execution_count": null,
1447 | "metadata": {
1448 | "slideshow": {
1449 | "slide_type": "fragment"
1450 | }
1451 | },
1452 | "outputs": [],
1453 | "source": [
1454 | "x = float(input(\"Enter value for x: \"))\n",
1455 | "y = 1/(x+1/(x+1/(x+1/x)))\n",
1456 | "\n",
1457 | "print(\"y =\", y)\n"
1458 | ]
1459 | },
1460 | {
1461 | "cell_type": "markdown",
1462 | "metadata": {
1463 | "slideshow": {
1464 | "slide_type": "subslide"
1465 | }
1466 | },
1467 | "source": [
1468 | "### Lab\n",
1469 | "Tugasmu adalah mempersiapkan kode simpel untuk menentukan waktu akhir/selesai sebuah kegiatan. Diberikan variabel durasi waktu dalam menit dan waktu mulai dalam jam (0..23)dan menit (0..59). hasilnya harus dicetak dalam console\n",
1470 | "\n",
1471 | "sebagai contoh, jika suatu kegiatan dimulai pukul `12:17` dan berlangsung selama `59 minutes` , maka kegiatan tersebut tersebut akan selesai pukul `13:16`\n",
1472 | "\n",
1473 | "jangan takut kalau kodemu belum sempurna, tidak masalah waktunya terlihat tidak valid, yang terpenting kodenya dapat menghasilkan nilai yang valid berdasarkan data input.\n",
1474 | "\n",
1475 | "Kode Dasar:\n",
1476 | "```python\n",
1477 | "jam = int(input(\"waktu mulai (jam): \"))\n",
1478 | "menit = int(input(\"waktu mulai (menit): \"))\n",
1479 | "durasi= int(input(\"durasi kegiatan (minutes): \"))\n",
1480 | "\n",
1481 | "# Letakkan kodemu disini\n",
1482 | "```\n",
1483 | "Uji Kodemu, Petunjuk ! gunakan operator % sebagai kunci suksesmu\n",
1484 | ",,"
1485 | ]
1486 | },
1487 | {
1488 | "cell_type": "code",
1489 | "execution_count": null,
1490 | "metadata": {
1491 | "slideshow": {
1492 | "slide_type": "subslide"
1493 | }
1494 | },
1495 | "outputs": [],
1496 | "source": [
1497 | "# coba di cek lagi\n",
1498 | "\n",
1499 | "jam = int(input(\"waktu mulai (jam): \"))\n",
1500 | "menit = int(input(\"waktu mulai (menit): \"))\n",
1501 | "durasi = int(input(\"durasi kegiatan (menit): \"))\n",
1502 | "\n",
1503 | "tambah_menit = menit + durasi\n",
1504 | "tambah_jam = int(tambah_menit / 60)\n",
1505 | "\n",
1506 | "jam += tambah_jam\n",
1507 | "menit = tambah_menit % 60\n",
1508 | "\n",
1509 | "print(str(jam%24)+':'+str(menit))"
1510 | ]
1511 | }
1512 | ],
1513 | "metadata": {
1514 | "kernelspec": {
1515 | "display_name": "Python 3",
1516 | "language": "python",
1517 | "name": "python3"
1518 | },
1519 | "language_info": {
1520 | "codemirror_mode": {
1521 | "name": "ipython",
1522 | "version": 3
1523 | },
1524 | "file_extension": ".py",
1525 | "mimetype": "text/x-python",
1526 | "name": "python",
1527 | "nbconvert_exporter": "python",
1528 | "pygments_lexer": "ipython3",
1529 | "version": "3.8.3"
1530 | },
1531 | "rise": {
1532 | "auto_select": "none",
1533 | "auto_select_fragment": false,
1534 | "footer": "netacad Indonesia
",
1535 | "header": "Python - PCAP
",
1536 | "scroll": true,
1537 | "theme": "sky",
1538 | "width": "90%"
1539 | }
1540 | },
1541 | "nbformat": 4,
1542 | "nbformat_minor": 2
1543 | }
1544 |
--------------------------------------------------------------------------------
/2021/PPT/01 Pengenalan Pemograman Python.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/2021/PPT/01 Pengenalan Pemograman Python.pdf
--------------------------------------------------------------------------------
/2021/PPT/readme.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/2021/readme.md:
--------------------------------------------------------------------------------
1 |
2 | # Modules
3 | Modul-modul python Notebook berikut dapat langsung dibuka melalui google colab, dengan meng-klik tautan pada setiap modul:
4 | * PE1 Module 1 - Pengenalan Python dan Bahasa Pemrograman [open colab](http://colab.research.google.com/github/sykrn/py-dts/blob/master/2021/PE1%20Module%201%20-%20Pengenalan%20Python%20dan%20Bahasa%20Pemrograman.ipynb)
5 | * PE1 Module 2 - Tipe Data, Variabel Dasar, Input Output, Operasi [open colab](http://colab.research.google.com/github/sykrn/py-dts/blob/master/2021/PE1%20Module%202%20-%20Tipe%20Data%2C%20Variabel%2C%20Dasar%20Input%20Output%2C%20Operasi.ipynb)
6 | * PE1 Module 3 - Operator, Kondisi, Perulangan, dan operasinya [open colab](http://colab.research.google.com/github/sykrn/py-dts/blob/master/2021/PE1%20Module%203%20-%20Operator%20kondisi%2C%20perulangan%2C%20list%20dan%20operasinya%2C%20bitwise%2C%20boolean.ipynb)
7 | * PE1 Module 4 - Functions, Tuples, Dictionaries, and Data Processing [open colab](http://colab.research.google.com/github/sykrn/py-dts/blob/master/2021/PE1%20Module%204%20-%20Function%20Tuple%20Dictionaries%20and%20Data%20Processing.ipynb)
8 | * PE2 Module 1 - Modules, Packages and PIP [open colab](http://colab.research.google.com/github/sykrn/py-dts/blob/master/2021/PE2%20Module%201%20-%20Modules%2C%20Packages%20and%20PIP.ipynb)
9 | * PE2 Module 2 - Exceptions, Strings, String and List Methods [open colab](http://colab.research.google.com/github/sykrn/py-dts/blob/master/2021/PE2%20Module%202%20-%20Exceptions%2C%20Strings%2C%20String%20and%20List%20Methods.ipynb)
10 | * PE2 Module 3 - Object-Oriented Programming in Python (OOP) [open colab](http://colab.research.google.com/github/sykrn/py-dts/blob/master/2021/PE2%20Module%203%20-%20Pemrograman%20Berbasis%20Obyek%20(PBO).ipynb)
11 | * PE2 Module 4 - Miscellaneous [open colab](http://colab.research.google.com/github/sykrn/py-dts/blob/master/2021/PE2%20Module%204%20-%20Miscellaneous.ipynb)
12 |
--------------------------------------------------------------------------------
/Modul 1 - Pengenalan Python dan Bahasa Pemrograman.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## Luaran Pembelajaran\n",
8 | "klik untuk [Open in colab](https://colab.research.google.com/github/sykrn/py-dts/blob/master/Modul%201%20-%20Pengenalan%20Python%20dan%20Bahasa%20Pemrograman.ipynb) \n",
9 | "- dasar-dasar pemrograman komputer;\n",
10 | "- mengatur lingkungan pemrograman;\n",
11 | "- compilation vs interpretation;\n",
12 | "- pengantar bahasa pemrograman Python.\n",
13 | "\n",
14 | "#### Masuk ke Slide Power Point"
15 | ]
16 | },
17 | {
18 | "cell_type": "code",
19 | "execution_count": 2,
20 | "metadata": {},
21 | "outputs": [
22 | {
23 | "name": "stdout",
24 | "output_type": "stream",
25 | "text": [
26 | "Hello World\n"
27 | ]
28 | }
29 | ],
30 | "source": [
31 | "# Your First Program\n",
32 | "\n",
33 | "print(\"Hello World\")"
34 | ]
35 | },
36 | {
37 | "cell_type": "markdown",
38 | "metadata": {},
39 | "source": [
40 | "## Instalasi python dan tools\n",
41 | "Cara dibawah ini pilih salah satu:\n",
42 | "\n",
43 | "1. Tidak perlu install apapun -> Pakai **sandbox** atau **Google Colab** (klik link colab setiap notebook)\n",
44 | "2. Install minimal python -> download di [python.org](https://www.python.org/) (Sudah termasuk package manager pip dan IDLE)\n",
45 | "> Saat menginstall, silakan centang **add to path variable** dan **change minimum path length** \n",
46 | "3. Install miniconda (minimum anaconda) - Command Line Interface (CLI) only [miniconda](https://docs.conda.io/en/latest/miniconda.html)\n",
47 | "4. Install Anaconda - Graphical User Interface (GUI) (sudah bisa install spyder, VSCode, dll) [download](https://www.anaconda.com/products/individual)\n",
48 | "\n",
49 | "### Editor & working space \n",
50 | "1. IDLE dari python.org\n",
51 | "2. Visual Studio Code -> Rcmd: install ekstensi `python` dari microsoft. [download](https://code.visualstudio.com/)\n",
52 | "3. Jupyter notebook di CLI baik menggunakan `pip` atau `conda`. [Install](https://jupyter.org/install)\n",
53 | "\n",
54 | "### CLI only untuk linux\n",
55 | "* bisa menggunakan `curl` atau `wget`"
56 | ]
57 | },
58 | {
59 | "cell_type": "code",
60 | "execution_count": null,
61 | "metadata": {},
62 | "outputs": [],
63 | "source": []
64 | }
65 | ],
66 | "metadata": {
67 | "kernelspec": {
68 | "display_name": "Python 3",
69 | "language": "python",
70 | "name": "python3"
71 | },
72 | "language_info": {
73 | "codemirror_mode": {
74 | "name": "ipython",
75 | "version": 3
76 | },
77 | "file_extension": ".py",
78 | "mimetype": "text/x-python",
79 | "name": "python",
80 | "nbconvert_exporter": "python",
81 | "pygments_lexer": "ipython3",
82 | "version": "3.7.4"
83 | }
84 | },
85 | "nbformat": 4,
86 | "nbformat_minor": 2
87 | }
88 |
--------------------------------------------------------------------------------
/Modul 2 - Tipe Data, Variabel, Dasar Input Output, Operasi.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {
6 | "slideshow": {
7 | "slide_type": "slide"
8 | }
9 | },
10 | "source": [
11 | "# Tipe data, Variable dan operasi dasar\n",
12 | "klik untuk [Open in colab](https://colab.research.google.com/github/sykrn/py-dts/blob/master/Modul%202%20-%20Tipe%20Data%2C%20Variabel%2C%20Dasar%20Input%20Output%2C%20Operasi.ipynb) "
13 | ]
14 | },
15 | {
16 | "cell_type": "markdown",
17 | "metadata": {
18 | "slideshow": {
19 | "slide_type": "slide"
20 | }
21 | },
22 | "source": [
23 | "## Luaran pembelajaran\n",
24 | "\n",
25 | "- tipe data dan metode dasar untuk memformat, mengkonversi, input dan output data;\n",
26 | "- operator;\n",
27 | "- variabel."
28 | ]
29 | },
30 | {
31 | "cell_type": "markdown",
32 | "metadata": {
33 | "slideshow": {
34 | "slide_type": "slide"
35 | }
36 | },
37 | "source": [
38 | "## 2.1.1 Program Pertama\n",
39 | "\n",
40 | "- mengenal fungsi `print()`;\n",
41 | "- tanda kurung buka;\n",
42 | "- tanda kutip;\n",
43 | "- kalimat 1 baris: `Hello, World!`;\n",
44 | "- fungsi beberapa tanda kutip lain;\n",
45 | "- tanda kurung tutup."
46 | ]
47 | },
48 | {
49 | "cell_type": "code",
50 | "execution_count": null,
51 | "metadata": {
52 | "slideshow": {
53 | "slide_type": "fragment"
54 | }
55 | },
56 | "outputs": [],
57 | "source": [
58 | "print(\"Hello, World!!!!!!\")\n",
59 | "print(\"Goodbye World!!!\")\n"
60 | ]
61 | },
62 | {
63 | "cell_type": "markdown",
64 | "metadata": {
65 | "slideshow": {
66 | "slide_type": "slide"
67 | }
68 | },
69 | "source": [
70 | "## Lab\n",
71 | "- Cetak kalimat \"Hello, Python!\"\n",
72 | "- Cetak nama pertamamu\n",
73 | "- Cetak nama pertamamu tanpa petik\n",
74 | "- apakah ada bedanya double quote \"\" dan single quote ' ?"
75 | ]
76 | },
77 | {
78 | "cell_type": "code",
79 | "execution_count": null,
80 | "metadata": {
81 | "scrolled": true,
82 | "slideshow": {
83 | "slide_type": "fragment"
84 | }
85 | },
86 | "outputs": [],
87 | "source": [
88 | "print(\"Hello, Python!\")\n",
89 | "print(\"Petik satu atau dua\")\n",
90 | "print('Petik satu atau dua')\n"
91 | ]
92 | },
93 | {
94 | "cell_type": "markdown",
95 | "metadata": {
96 | "slideshow": {
97 | "slide_type": "slide"
98 | }
99 | },
100 | "source": [
101 | "## Formatting dengan Special Character\n",
102 | "- `\\` = karakter spesial \"escaping nature\"\n",
103 | "\n",
104 | "- `\\n` = untuk enter\n",
105 | "\n",
106 | "- `\\` = escaping karakter\n",
107 | "\n",
108 | "```python\n",
109 | "print() = berarti line kosong\n",
110 | "```\n",
111 | "\n",
112 | "Tidak boleh ada 2 perintah dalam 1 baris\n",
113 | "```python\n",
114 | "print(\"nama depan\") print (\"nama belakang\")\n",
115 | "```"
116 | ]
117 | },
118 | {
119 | "cell_type": "code",
120 | "execution_count": null,
121 | "metadata": {
122 | "scrolled": true,
123 | "slideshow": {
124 | "slide_type": "subslide"
125 | }
126 | },
127 | "outputs": [],
128 | "source": [
129 | "print(\"seketika langit menjadi gelap\\nkemudian hujan turun dengan deras.\")\n",
130 | "print()\n",
131 | "print(\"ibu memasak di dapur\\ndan kakak menyapu di halaman.\")\n",
132 | " "
133 | ]
134 | },
135 | {
136 | "cell_type": "code",
137 | "execution_count": null,
138 | "metadata": {
139 | "cell_style": "split",
140 | "slideshow": {
141 | "slide_type": "fragment"
142 | }
143 | },
144 | "outputs": [],
145 | "source": [
146 | "print(\"\\\"\")\n"
147 | ]
148 | },
149 | {
150 | "cell_type": "code",
151 | "execution_count": null,
152 | "metadata": {
153 | "cell_style": "split",
154 | "scrolled": false,
155 | "slideshow": {
156 | "slide_type": "fragment"
157 | }
158 | },
159 | "outputs": [],
160 | "source": [
161 | "print(\"\\\\\")\n"
162 | ]
163 | },
164 | {
165 | "cell_type": "code",
166 | "execution_count": null,
167 | "metadata": {
168 | "slideshow": {
169 | "slide_type": "fragment"
170 | }
171 | },
172 | "outputs": [],
173 | "source": [
174 | "# Dia mengatakan \"halo\"\n",
175 | "print(\"Dia mengatakan \\\"halo\\\"\")\n"
176 | ]
177 | },
178 | {
179 | "cell_type": "markdown",
180 | "metadata": {
181 | "slideshow": {
182 | "slide_type": "subslide"
183 | }
184 | },
185 | "source": [
186 | "Beberapa kalimat dapat dipisahkan dengan koma"
187 | ]
188 | },
189 | {
190 | "cell_type": "code",
191 | "execution_count": null,
192 | "metadata": {
193 | "slideshow": {
194 | "slide_type": "fragment"
195 | }
196 | },
197 | "outputs": [],
198 | "source": [
199 | "print(\"The itsy bitsy spider.\" , \"climbed up.\" , \"the waterspout.\")\n",
200 | " "
201 | ]
202 | },
203 | {
204 | "cell_type": "code",
205 | "execution_count": null,
206 | "metadata": {
207 | "slideshow": {
208 | "slide_type": "fragment"
209 | }
210 | },
211 | "outputs": [],
212 | "source": [
213 | "print(\"My name is\", \"Python.\")\n",
214 | "print(\"Monty Python.\")\n"
215 | ]
216 | },
217 | {
218 | "cell_type": "markdown",
219 | "metadata": {
220 | "slideshow": {
221 | "slide_type": "subslide"
222 | }
223 | },
224 | "source": [
225 | "```end=\" \"``` digunakan untuk meletakkan argumen setelah argumen pertama"
226 | ]
227 | },
228 | {
229 | "cell_type": "code",
230 | "execution_count": null,
231 | "metadata": {},
232 | "outputs": [],
233 | "source": [
234 | "print(\"My name is\", \"Python.\", end=\" \")\n",
235 | "print(\"Monty Python.\")\n"
236 | ]
237 | },
238 | {
239 | "cell_type": "code",
240 | "execution_count": null,
241 | "metadata": {},
242 | "outputs": [],
243 | "source": [
244 | "print(\"My name is \", end=\" ## \")\n",
245 | "print(\"Monty Python.\")\n"
246 | ]
247 | },
248 | {
249 | "cell_type": "markdown",
250 | "metadata": {
251 | "slideshow": {
252 | "slide_type": "subslide"
253 | }
254 | },
255 | "source": [
256 | "```sep=\" \" ``` digunakan untuk memisahkan antar argumen dengan string kosong atau karakter lain"
257 | ]
258 | },
259 | {
260 | "cell_type": "code",
261 | "execution_count": null,
262 | "metadata": {},
263 | "outputs": [],
264 | "source": [
265 | "print(\"My\", \"name\", \"is\", \"Monty\", \"Python.\", sep=\"-\")"
266 | ]
267 | },
268 | {
269 | "cell_type": "code",
270 | "execution_count": null,
271 | "metadata": {},
272 | "outputs": [],
273 | "source": [
274 | "print(\"My\", \"name\", \"is\", sep=\"_\", end=\"*\")\n",
275 | "print(\"Monty\", \"Python.\", sep=\"*\", end=\"*\\n\")\n",
276 | "print(\"Digital\", \"Talent\", \"Dahsyat\", sep=\"_\", end=\"*\")\n",
277 | "print(\"Guntur\", \"Budi.\", sep=\"*\", end=\"*\\n\")"
278 | ]
279 | },
280 | {
281 | "cell_type": "markdown",
282 | "metadata": {
283 | "slideshow": {
284 | "slide_type": "subslide"
285 | }
286 | },
287 | "source": [
288 | "## Lab\n",
289 | "\n",
290 | "Buatlah Program untuk menghasilkan output:\n",
291 | "`Programming***Essentials***in...Python`"
292 | ]
293 | },
294 | {
295 | "cell_type": "code",
296 | "execution_count": null,
297 | "metadata": {
298 | "slideshow": {
299 | "slide_type": "fragment"
300 | }
301 | },
302 | "outputs": [],
303 | "source": [
304 | "print(\"Programming\",\"Essentials\",\"in\",sep=\"***\",end=\"...\")\n",
305 | "print(\"Python\")\n"
306 | ]
307 | },
308 | {
309 | "cell_type": "markdown",
310 | "metadata": {
311 | "slideshow": {
312 | "slide_type": "subslide"
313 | }
314 | },
315 | "source": [
316 | "## Lab\n",
317 | "\n",
318 | "Buatlah program dengan output sebagai berikut:\n",
319 | "```\n",
320 | " *\n",
321 | " * *\n",
322 | " * *\n",
323 | " * *\n",
324 | "*** ***\n",
325 | " * *\n",
326 | " * *\n",
327 | " ***** ```"
328 | ]
329 | },
330 | {
331 | "cell_type": "code",
332 | "execution_count": null,
333 | "metadata": {
334 | "slideshow": {
335 | "slide_type": "subslide"
336 | }
337 | },
338 | "outputs": [],
339 | "source": [
340 | "print(\" *\\n * *\\n * *\\n * *\\n*** ***\\n * *\\n * *\\n *****\\n\"*2)\n"
341 | ]
342 | },
343 | {
344 | "cell_type": "code",
345 | "execution_count": null,
346 | "metadata": {
347 | "slideshow": {
348 | "slide_type": "subslide"
349 | }
350 | },
351 | "outputs": [],
352 | "source": [
353 | "print(\" * \"*2)\n",
354 | "print(\" * * \"*2)\n",
355 | "print(\" * * \"*2)\n",
356 | "print(\" * * \"*2)\n",
357 | "print(\"*** ***\"*2)\n",
358 | "print(\" * * \"*2)\n",
359 | "print(\" * * \"*2)\n",
360 | "print(\" ***** \"*2)\n"
361 | ]
362 | },
363 | {
364 | "cell_type": "markdown",
365 | "metadata": {
366 | "slideshow": {
367 | "slide_type": "slide"
368 | }
369 | },
370 | "source": [
371 | "## 2.1.2 Literals\n",
372 | "literal merupakan notasi untuk mensimbolkan nilai, dapat berupa string, boolean maupun angka (integer dan float)"
373 | ]
374 | },
375 | {
376 | "cell_type": "code",
377 | "execution_count": null,
378 | "metadata": {
379 | "slideshow": {
380 | "slide_type": "fragment"
381 | }
382 | },
383 | "outputs": [],
384 | "source": [
385 | "# hasil output akan terlihat sama, namun nilai tersebut tersimpan berbeda dalam memori komputer\n",
386 | "print(\"2\")\n",
387 | "print(2)\n",
388 | "\n",
389 | "print(type(\"2\"))\n",
390 | "print(type(2))\n"
391 | ]
392 | },
393 | {
394 | "cell_type": "markdown",
395 | "metadata": {
396 | "slideshow": {
397 | "slide_type": "subslide"
398 | }
399 | },
400 | "source": [
401 | "## Integers vs Floats\n"
402 | ]
403 | },
404 | {
405 | "cell_type": "code",
406 | "execution_count": null,
407 | "metadata": {
408 | "slideshow": {
409 | "slide_type": "fragment"
410 | }
411 | },
412 | "outputs": [],
413 | "source": [
414 | "print(5, \"mempunyai tipe\", type(5))\n",
415 | "\n",
416 | "print(5.0, \"mempunyai tipe\", type(5.0))\n"
417 | ]
418 | },
419 | {
420 | "cell_type": "markdown",
421 | "metadata": {
422 | "slideshow": {
423 | "slide_type": "subslide"
424 | }
425 | },
426 | "source": [
427 | "\n",
428 | "## Penulisan Float dan Integer\n",
429 | "Python versi 3 membolehkan pemisahan digit integer dengan underscore \"_\"\n",
430 | "agar mudah dibaca\n",
431 | "```python\n",
432 | "print (10_000_000)```\n",
433 | "\n",
434 | "Float dipisahkan dengan .(titik) bukan ,(koma)\n",
435 | "cara penulisan float bisa 3 cara\n",
436 | "\n",
437 | "- 4.0\n",
438 | "- .4 (terbaca nol koma 4)\n",
439 | "- 4. (terbaca 4 koma nol)\n",
440 | "\n",
441 | "> 3e08 berarti $ 3 x 10 ^ 8 $ \n",
442 | "3e-08 berarti $ 3 x 10 ^ {-8} $\n"
443 | ]
444 | },
445 | {
446 | "cell_type": "code",
447 | "execution_count": null,
448 | "metadata": {
449 | "slideshow": {
450 | "slide_type": "fragment"
451 | }
452 | },
453 | "outputs": [],
454 | "source": [
455 | "print (0.000000003)\n",
456 | "print (3e-8)\n"
457 | ]
458 | },
459 | {
460 | "cell_type": "markdown",
461 | "metadata": {
462 | "slideshow": {
463 | "slide_type": "subslide"
464 | }
465 | },
466 | "source": [
467 | "## String\n",
468 | "\n",
469 | "Buatlah program untuk menghasilkan output `I'm Monty Python`"
470 | ]
471 | },
472 | {
473 | "cell_type": "code",
474 | "execution_count": null,
475 | "metadata": {
476 | "slideshow": {
477 | "slide_type": "fragment"
478 | }
479 | },
480 | "outputs": [],
481 | "source": [
482 | "print(\"I'm Monty Python\")\n",
483 | "print(\"Jum'at\")\n",
484 | "print('\"Saya berpendapat python itu mudah\", kata Monty')\n",
485 | "print(\"1.5\")\n",
486 | "print(\"1000\")\n"
487 | ]
488 | },
489 | {
490 | "cell_type": "code",
491 | "execution_count": null,
492 | "metadata": {
493 | "slideshow": {
494 | "slide_type": "fragment"
495 | }
496 | },
497 | "outputs": [],
498 | "source": [
499 | "#string kosong pun juga bernilai string\n",
500 | "print(\"\")\n",
501 | "print('')\n"
502 | ]
503 | },
504 | {
505 | "cell_type": "markdown",
506 | "metadata": {
507 | "slideshow": {
508 | "slide_type": "subslide"
509 | }
510 | },
511 | "source": [
512 | "## Booelan\n",
513 | "Logika benar salah, 1 bernilai benar (True) dan 0 bernilai salah (False)"
514 | ]
515 | },
516 | {
517 | "cell_type": "code",
518 | "execution_count": null,
519 | "metadata": {
520 | "slideshow": {
521 | "slide_type": "fragment"
522 | }
523 | },
524 | "outputs": [],
525 | "source": [
526 | "print(True)\n",
527 | "print(False)\n",
528 | "print (3>0)\n",
529 | "print (0>3)"
530 | ]
531 | },
532 | {
533 | "cell_type": "markdown",
534 | "metadata": {
535 | "slideshow": {
536 | "slide_type": "subslide"
537 | }
538 | },
539 | "source": [
540 | "## None"
541 | ]
542 | },
543 | {
544 | "cell_type": "code",
545 | "execution_count": null,
546 | "metadata": {
547 | "slideshow": {
548 | "slide_type": "fragment"
549 | }
550 | },
551 | "outputs": [],
552 | "source": [
553 | "print(None)"
554 | ]
555 | },
556 | {
557 | "cell_type": "markdown",
558 | "metadata": {
559 | "slideshow": {
560 | "slide_type": "subslide"
561 | }
562 | },
563 | "source": [
564 | "## Lab\n",
565 | "Buat output seperti ini dalam satu line
\n",
566 | "`\"I'm\"`
\n",
567 | "`\"\"learning\"\"`
\n",
568 | "`\"\"\"Python\"\"\"`"
569 | ]
570 | },
571 | {
572 | "cell_type": "code",
573 | "execution_count": null,
574 | "metadata": {
575 | "slideshow": {
576 | "slide_type": "fragment"
577 | }
578 | },
579 | "outputs": [],
580 | "source": [
581 | "print('\"I\\'m\"\\n\"\"learning\"\"\\n\"\"\"Python\"\"\"')\n",
582 | "\n",
583 | "print(\"\"\"\n",
584 | "\"I'm\"\n",
585 | "\"\"learning\"\"\n",
586 | "\\\"\"\"Python\"\"\\\"\n",
587 | "\"\"\")"
588 | ]
589 | },
590 | {
591 | "cell_type": "markdown",
592 | "metadata": {
593 | "slideshow": {
594 | "slide_type": "slide"
595 | }
596 | },
597 | "source": [
598 | "# 2.1.3 Operator"
599 | ]
600 | },
601 | {
602 | "cell_type": "markdown",
603 | "metadata": {
604 | "slideshow": {
605 | "slide_type": "fragment"
606 | }
607 | },
608 | "source": [
609 | "### Operator Aritmetika\n",
610 | "\n",
611 | "| Operator | Arti | Contoh |\n",
612 | "|----------|--------------------------------------------------------------------------------------------------|--------------------------|\n",
613 | "| + | Penambahan | x + y |\n",
614 | "| - | Pengurangan | x - y |\n",
615 | "| * | Perkalian | x * y |\n",
616 | "| / | Pembagian | x / y |\n",
617 | "| % | Modulo - Sisa Pembagian | x % y (sisa pembagian of x/y) |\n",
618 | "| // | Pembagian dan dibulatkan ke bawah | x // y |\n",
619 | "| ** | Eksponen - Pangkat | x**y (x pangkat y) |"
620 | ]
621 | },
622 | {
623 | "cell_type": "code",
624 | "execution_count": null,
625 | "metadata": {
626 | "slideshow": {
627 | "slide_type": "subslide"
628 | }
629 | },
630 | "outputs": [],
631 | "source": [
632 | "#eksponen/pangkat\n",
633 | "print(2 ** 3)\n",
634 | "print(2 ** 3.)\n",
635 | "print(2. ** 3)\n",
636 | "print(2. ** 3.)\n"
637 | ]
638 | },
639 | {
640 | "cell_type": "code",
641 | "execution_count": null,
642 | "metadata": {
643 | "slideshow": {
644 | "slide_type": "fragment"
645 | }
646 | },
647 | "outputs": [],
648 | "source": [
649 | "#pembagian\n",
650 | "print(6 / 3)\n",
651 | "print(6 / 3.)\n",
652 | "print(6. / 3)\n",
653 | "print(6. / 3.)\n"
654 | ]
655 | },
656 | {
657 | "cell_type": "code",
658 | "execution_count": null,
659 | "metadata": {
660 | "slideshow": {
661 | "slide_type": "subslide"
662 | }
663 | },
664 | "outputs": [],
665 | "source": [
666 | "#pembagian dengan pembulatan ke bawah\n",
667 | "print(6 // 3)\n",
668 | "print(6 // 3.)\n",
669 | "print(6. // 3)\n",
670 | "print(6. // 3.)\n"
671 | ]
672 | },
673 | {
674 | "cell_type": "code",
675 | "execution_count": null,
676 | "metadata": {
677 | "slideshow": {
678 | "slide_type": "fragment"
679 | }
680 | },
681 | "outputs": [],
682 | "source": [
683 | "print(6 // 4)\n",
684 | "print(6. // 4)\n",
685 | "\n",
686 | "print(6 / 4)\n",
687 | "print(6. / 4)\n",
688 | "\n",
689 | "#Penting ! pembulatan selalu ke nilai bawahnya\n"
690 | ]
691 | },
692 | {
693 | "cell_type": "code",
694 | "execution_count": null,
695 | "metadata": {
696 | "slideshow": {
697 | "slide_type": "fragment"
698 | }
699 | },
700 | "outputs": [],
701 | "source": [
702 | "print(-6 // 4)\n",
703 | "print(6. // -4)\n"
704 | ]
705 | },
706 | {
707 | "cell_type": "code",
708 | "execution_count": null,
709 | "metadata": {
710 | "slideshow": {
711 | "slide_type": "subslide"
712 | }
713 | },
714 | "outputs": [],
715 | "source": [
716 | "#modulo/sisa bagi\n",
717 | "print(14 % 4)\n"
718 | ]
719 | },
720 | {
721 | "cell_type": "code",
722 | "execution_count": null,
723 | "metadata": {
724 | "slideshow": {
725 | "slide_type": "fragment"
726 | }
727 | },
728 | "outputs": [],
729 | "source": [
730 | "print(-4 + 4)\n",
731 | "print(-4. + 8)\n"
732 | ]
733 | },
734 | {
735 | "cell_type": "markdown",
736 | "metadata": {
737 | "slideshow": {
738 | "slide_type": "subslide"
739 | }
740 | },
741 | "source": [
742 | "### Urutan Operator"
743 | ]
744 | },
745 | {
746 | "cell_type": "code",
747 | "execution_count": null,
748 | "metadata": {
749 | "slideshow": {
750 | "slide_type": "fragment"
751 | }
752 | },
753 | "outputs": [],
754 | "source": [
755 | "#perkalian lebih didahulukan dari penambahan\n",
756 | "2 + 3 * 5\n"
757 | ]
758 | },
759 | {
760 | "cell_type": "code",
761 | "execution_count": null,
762 | "metadata": {
763 | "slideshow": {
764 | "slide_type": "fragment"
765 | }
766 | },
767 | "outputs": [],
768 | "source": [
769 | "#pengerjaan dari kiri ke kanan\n",
770 | "print(9 % 6 % 2)\n"
771 | ]
772 | },
773 | {
774 | "cell_type": "code",
775 | "execution_count": null,
776 | "metadata": {
777 | "slideshow": {
778 | "slide_type": "fragment"
779 | }
780 | },
781 | "outputs": [],
782 | "source": [
783 | "#pengerjaan dari kanan ke kiri\n",
784 | "print(2 ** 2 ** 3)\n"
785 | ]
786 | },
787 | {
788 | "cell_type": "markdown",
789 | "metadata": {
790 | "slideshow": {
791 | "slide_type": "subslide"
792 | }
793 | },
794 | "source": [
795 | "| Prioritas| Operator | ket |\n",
796 | "|----------|----------|--------|\n",
797 | "| 1 | +, - | unary |\n",
798 | "| 2 | ** | |\n",
799 | "| 3 | *, /, % | |\n",
800 | "| 4 | +, - | binary |"
801 | ]
802 | },
803 | {
804 | "cell_type": "code",
805 | "execution_count": null,
806 | "metadata": {
807 | "slideshow": {
808 | "slide_type": "fragment"
809 | }
810 | },
811 | "outputs": [],
812 | "source": [
813 | "print((5 * ((25 % 13) + 100) / (2 * 13)) // 2)\n"
814 | ]
815 | },
816 | {
817 | "cell_type": "markdown",
818 | "metadata": {
819 | "slideshow": {
820 | "slide_type": "subslide"
821 | }
822 | },
823 | "source": [
824 | "### Latihan\n",
825 | "\n",
826 | "`print((2 ** 4), (2 * 4.), (2 * 4))`
\n",
827 | "`print((-2 / 4), (2 / 4), (2 // 4), (-2 // 4))`
\n",
828 | "`print((2 % -4), (2 % 4), (2 ** 3 ** 2))`
"
829 | ]
830 | },
831 | {
832 | "cell_type": "markdown",
833 | "metadata": {
834 | "slideshow": {
835 | "slide_type": "slide"
836 | }
837 | },
838 | "source": [
839 | "# 2.1.4 Variabel\n",
840 | "- Apa itu variabel?\n",
841 | "- Bagaimana Aturan Penamaannya?\n"
842 | ]
843 | },
844 | {
845 | "cell_type": "code",
846 | "execution_count": null,
847 | "metadata": {
848 | "slideshow": {
849 | "slide_type": "fragment"
850 | }
851 | },
852 | "outputs": [],
853 | "source": [
854 | "# kamu bisa menaruh tipe data apapun dalam variabel\n",
855 | "var = 1 # bukan operasi matematika, namun operasi assignment i.e., var <-- 1\n",
856 | "print(var)\n"
857 | ]
858 | },
859 | {
860 | "cell_type": "markdown",
861 | "metadata": {
862 | "slideshow": {
863 | "slide_type": "fragment"
864 | }
865 | },
866 | "source": [
867 | "- baris pertama membuat variabel dengan nama `var`, dan diisi dengan nilai `1`.\n",
868 | "- baris kedua mencetak nilai dalam variabel ke dalam console"
869 | ]
870 | },
871 | {
872 | "cell_type": "code",
873 | "execution_count": null,
874 | "metadata": {
875 | "slideshow": {
876 | "slide_type": "subslide"
877 | }
878 | },
879 | "outputs": [],
880 | "source": [
881 | "var = 1\n",
882 | "saldo = 1000.0\n",
883 | "namaKlien = 'John Doe'\n",
884 | "print(var, saldo, namaKlien)\n",
885 | "print(var)\n"
886 | ]
887 | },
888 | {
889 | "cell_type": "code",
890 | "execution_count": null,
891 | "metadata": {
892 | "slideshow": {
893 | "slide_type": "fragment"
894 | }
895 | },
896 | "outputs": [],
897 | "source": [
898 | "#case sensitive, huruf besar kecil perlu diperhatikan!\n",
899 | "var = 1\n",
900 | "print(Var) "
901 | ]
902 | },
903 | {
904 | "cell_type": "code",
905 | "execution_count": null,
906 | "metadata": {
907 | "slideshow": {
908 | "slide_type": "fragment"
909 | }
910 | },
911 | "outputs": [],
912 | "source": [
913 | "#tanda '+' bisa digunakan untuk kontatinasi untuk type string\n",
914 | "var = \"2019\"\n",
915 | "print(\"Digital talent: \" + var)"
916 | ]
917 | },
918 | {
919 | "cell_type": "code",
920 | "execution_count": null,
921 | "metadata": {
922 | "slideshow": {
923 | "slide_type": "subslide"
924 | }
925 | },
926 | "outputs": [],
927 | "source": [
928 | "#menetapkan nilai baru ke dalam variabel yang telah ada \n",
929 | "#menugaskan variabel\n",
930 | "\n",
931 | "var = 1\n",
932 | "print(var)\n",
933 | "var = var + 1\n",
934 | "print(var)"
935 | ]
936 | },
937 | {
938 | "cell_type": "code",
939 | "execution_count": null,
940 | "metadata": {
941 | "slideshow": {
942 | "slide_type": "fragment"
943 | }
944 | },
945 | "outputs": [],
946 | "source": [
947 | "var = 100\n",
948 | "var = 200 + 300\n",
949 | "print(var)"
950 | ]
951 | },
952 | {
953 | "cell_type": "markdown",
954 | "metadata": {
955 | "slideshow": {
956 | "slide_type": "subslide"
957 | }
958 | },
959 | "source": [
960 | "### Latihan\n",
961 | "Tulis rumus ini dalam kode program:
$c=\\sqrt{a^2+b^2}$"
962 | ]
963 | },
964 | {
965 | "cell_type": "code",
966 | "execution_count": null,
967 | "metadata": {
968 | "slideshow": {
969 | "slide_type": "fragment"
970 | }
971 | },
972 | "outputs": [],
973 | "source": [
974 | "a = 3.0\n",
975 | "b = 4.0\n",
976 | "c = (a ** 2 + b ** 2) ** 0.5\n",
977 | "print(\"c =\", c)"
978 | ]
979 | },
980 | {
981 | "cell_type": "markdown",
982 | "metadata": {
983 | "slideshow": {
984 | "slide_type": "subslide"
985 | }
986 | },
987 | "source": [
988 | "### Lab\n",
989 | "\n",
990 | "Cerita Pendek: \n",
991 | "\n",
992 | "Suatu waktu di kebun apel, Guntur memiliki 3 apel, Icha memiliki 5 apel dan Ratna memiliki 6 Apel. mereka sangat bahagia dan hidup lama. selesai.\n",
993 | "\n",
994 | "Tugas Anda\n",
995 | "- buat variabe : `Guntur`, `Icha` dan `Ratna`\n",
996 | "- isi nilai sesuai dengan jumlah apel yang mereka miliki\n",
997 | "- cetak nama variabel dan jumlah apel setiap variabel dalam 1 baris, pisahkan dengan koma\n",
998 | "- buat variabel baru dengan nama `totalApel` yang berisi penjumlahan seluruh apel yang mereka miliki\n",
999 | "- coba otak atik code dengan membuat variable baru, diisi dengan nilai lain, dan dihitung dengan operator aritmetik lainnya\n"
1000 | ]
1001 | },
1002 | {
1003 | "cell_type": "code",
1004 | "execution_count": null,
1005 | "metadata": {
1006 | "slideshow": {
1007 | "slide_type": "subslide"
1008 | }
1009 | },
1010 | "outputs": [],
1011 | "source": [
1012 | "Guntur = 3\n",
1013 | "Icha = 5\n",
1014 | "Ratna = 6\n",
1015 | "\n",
1016 | "print(\"Apel milik Guntur\",Guntur)\n",
1017 | "print(\"Apel milik Guntur\",Icha)\n",
1018 | "print(\"Apel milik Guntur\",Ratna)\n",
1019 | "\n",
1020 | "totalApel = Guntur + Icha + Ratna\n",
1021 | "print(\"Total number of apples: \" , totalApel)"
1022 | ]
1023 | },
1024 | {
1025 | "cell_type": "code",
1026 | "execution_count": null,
1027 | "metadata": {
1028 | "slideshow": {
1029 | "slide_type": "subslide"
1030 | }
1031 | },
1032 | "outputs": [],
1033 | "source": [
1034 | "#Jalan Pintas operator\n",
1035 | "\n",
1036 | "sheep = 5\n",
1037 | "sheep = sheep + 1\n",
1038 | "print(sheep)\n",
1039 | "\n",
1040 | "sheep += 3\n",
1041 | "print(sheep)\n",
1042 | "\n",
1043 | "sheep *= 2\n",
1044 | "print(sheep)"
1045 | ]
1046 | },
1047 | {
1048 | "cell_type": "markdown",
1049 | "metadata": {
1050 | "slideshow": {
1051 | "slide_type": "subslide"
1052 | }
1053 | },
1054 | "source": [
1055 | "### Lab\n",
1056 | "\n",
1057 | "Mil dan kilometer adalah satuan panjang\n",
1058 | "\n",
1059 | "1 mil memiliki panjang sekitar 1.61 kilometer, buatlah program konversi di bawah ini\n",
1060 | "- mil ke kilometer;\n",
1061 | "- kilometer to mil.\n",
1062 | "jangan ganti apapun terhadap kode yang sudah ada. tulis kodemu pada tanda ###, kemudian hapus tanda tersebut. Uji kode Anda dengan data yang kami sajikan dalam source code\n"
1063 | ]
1064 | },
1065 | {
1066 | "cell_type": "markdown",
1067 | "metadata": {
1068 | "slideshow": {
1069 | "slide_type": "subslide"
1070 | }
1071 | },
1072 | "source": [
1073 | "Kode:\n",
1074 | "```python\n",
1075 | "kilometer = 12.25\n",
1076 | "mil = 7.38\n",
1077 | "\n",
1078 | "mil_ke_kilometer = ###\n",
1079 | "kilometer_ke_mil = ###\n",
1080 | "\n",
1081 | "print(mil, \"1 mil adalah\", round(miles_to_kilometers, 2), \"kilometer\")\n",
1082 | "print(kilometer, \"1 kilometer adalah\", round(kilometers_to_miles, 2), \"mil\")\n",
1083 | "```"
1084 | ]
1085 | },
1086 | {
1087 | "cell_type": "code",
1088 | "execution_count": null,
1089 | "metadata": {
1090 | "slideshow": {
1091 | "slide_type": "subslide"
1092 | }
1093 | },
1094 | "outputs": [],
1095 | "source": [
1096 | "kilometer = 12.25\n",
1097 | "mil = 7.61\n",
1098 | "\n",
1099 | "mil_ke_kilometer = mil * 1.61\n",
1100 | "kilometer_ke_mil = kilometer / 1.61\n",
1101 | "\n",
1102 | "print(mil, \"mil adalah\", round(mil_ke_kilometer, 2), \"kilometer\")\n",
1103 | "print(kilometer, \"kilometer adalah\", round(kilometer_ke_mil, 2), \"mil\")"
1104 | ]
1105 | },
1106 | {
1107 | "cell_type": "markdown",
1108 | "metadata": {
1109 | "slideshow": {
1110 | "slide_type": "subslide"
1111 | }
1112 | },
1113 | "source": [
1114 | "### Lab\n",
1115 | "\n",
1116 | "Skenario\n",
1117 | "lihatlah kode dalam editor, nilai tersebut termasuk tipe float, letakkan nilai tersebut dalam variabel x, dan print variabel tersebut dalam variabel y. Tugasmu adalah melengkapi kode di bawah ini untk menyelesaikan persamaan di bawah\n",
1118 | "\n",
1119 | "$3x^3 - 2x^2 + 3x - 1$\n",
1120 | "\n",
1121 | "Hasil harus disimpan dalam variabel y.\n",
1122 | "ingat bahwa aljabar klasik sering menghilangkan operator perkalian, kamu harus menggunakannya secara eksplisit. Ingat bagaimana cara mengubah tipe data untuk memastikan bahwa x bertipe float.\n",
1123 | "\n",
1124 | "usahakan kodemu mudah dibaca, uji kode dengan data yang telah kami berikan.\n",
1125 | "\n",
1126 | "```python\n",
1127 | "x = # hardcode your test data here\n",
1128 | "x = float(x)\n",
1129 | "# tulis kodemu disini\n",
1130 | "print(\"y =\", y)\n",
1131 | "```\n",
1132 | "\n",
1133 | "Test Data:\n",
1134 | "```python\n",
1135 | "#input\n",
1136 | "x = 0\n",
1137 | "x = 1\n",
1138 | "x = -1\n",
1139 | "\n",
1140 | "#output\n",
1141 | "y = -1.0\n",
1142 | "y = 3.0\n",
1143 | "y = -9.0\n",
1144 | "```"
1145 | ]
1146 | },
1147 | {
1148 | "cell_type": "code",
1149 | "execution_count": null,
1150 | "metadata": {
1151 | "slideshow": {
1152 | "slide_type": "subslide"
1153 | }
1154 | },
1155 | "outputs": [],
1156 | "source": [
1157 | "x = -1\n",
1158 | "x = float(x)\n",
1159 | "y = 3*x**3 - 2*x**2 + 3*x -1\n",
1160 | "print(\"y =\", y)"
1161 | ]
1162 | },
1163 | {
1164 | "cell_type": "markdown",
1165 | "metadata": {
1166 | "slideshow": {
1167 | "slide_type": "subslide"
1168 | }
1169 | },
1170 | "source": [
1171 | "### Exercise\n",
1172 | "\n",
1173 | "Apa outputnya?\n",
1174 | "```python\n",
1175 | "var = 2\n",
1176 | "var = 3\n",
1177 | "print(var)\n",
1178 | "```\n",
1179 | "\n",
1180 | "Nama variabel mana yang ilegal?\n",
1181 | "```python\n",
1182 | "my_var\n",
1183 | "m\n",
1184 | "101\n",
1185 | "averylongvariablename\n",
1186 | "m101\n",
1187 | "m 101\n",
1188 | "Del\n",
1189 | "del\n",
1190 | "```\n",
1191 | "\n",
1192 | "Apa Outputnya?\n",
1193 | "```python\n",
1194 | "a = '1'\n",
1195 | "b = \"1\"\n",
1196 | "print(a + b)\n",
1197 | "```\n",
1198 | "\n",
1199 | "Apa outputnya?\n",
1200 | "\n",
1201 | "```python\n",
1202 | "a = 6\n",
1203 | "b = 3\n",
1204 | "a /= 2 * b\n",
1205 | "print(a)\n",
1206 | "```"
1207 | ]
1208 | },
1209 | {
1210 | "cell_type": "markdown",
1211 | "metadata": {
1212 | "slideshow": {
1213 | "slide_type": "slide"
1214 | }
1215 | },
1216 | "source": [
1217 | "# 2.1.5 Comments\n",
1218 | "Latihan: mana yang seharusnya menjadi komentar, mana yang tidak"
1219 | ]
1220 | },
1221 | {
1222 | "cell_type": "code",
1223 | "execution_count": null,
1224 | "metadata": {
1225 | "slideshow": {
1226 | "slide_type": "fragment"
1227 | }
1228 | },
1229 | "outputs": [],
1230 | "source": [
1231 | "#this program computes the number of seconds in a given number of hours\n",
1232 | "# this program has been written two days ago\n",
1233 | "\n",
1234 | "a = 2 # number of hours\n",
1235 | "seconds = 3600 # number of seconds in 1 hour\n",
1236 | "\n",
1237 | "print(\"Hours: \", a) #printing the number of hours\n",
1238 | "# print(\"Seconds in Hours: \", a * seconds) # printing the number of seconds in a given number of hours\n",
1239 | "\n",
1240 | "#here we should also print \"Goodbye\", but a programmer didn't have time to write any code\n",
1241 | "#this is the end of the program that computes the number of seconds in 3 hour\n"
1242 | ]
1243 | },
1244 | {
1245 | "cell_type": "markdown",
1246 | "metadata": {
1247 | "slideshow": {
1248 | "slide_type": "slide"
1249 | }
1250 | },
1251 | "source": [
1252 | "# 2.1.6 How to talk to a computer \n",
1253 | "katakunci `input()`
\n",
1254 | "hasil dari fungsi `input()` adalah string.
\n",
1255 | "Tidak bisa langsung dikenakan ke operasi aritmetika"
1256 | ]
1257 | },
1258 | {
1259 | "cell_type": "code",
1260 | "execution_count": null,
1261 | "metadata": {
1262 | "slideshow": {
1263 | "slide_type": "fragment"
1264 | }
1265 | },
1266 | "outputs": [],
1267 | "source": [
1268 | "print(\"Tell me anything...\")\n",
1269 | "anything = input()\n",
1270 | "print(\"Hmm...\", anything, \"... Really?\")\n"
1271 | ]
1272 | },
1273 | {
1274 | "cell_type": "code",
1275 | "execution_count": null,
1276 | "metadata": {
1277 | "slideshow": {
1278 | "slide_type": "fragment"
1279 | }
1280 | },
1281 | "outputs": [],
1282 | "source": [
1283 | "angka = input(\"Masukkan Angka...\")\n",
1284 | "print(\"Pangkat duanya adalah\", angka*2)\n"
1285 | ]
1286 | },
1287 | {
1288 | "cell_type": "markdown",
1289 | "metadata": {
1290 | "slideshow": {
1291 | "slide_type": "subslide"
1292 | }
1293 | },
1294 | "source": [
1295 | "### type casting"
1296 | ]
1297 | },
1298 | {
1299 | "cell_type": "code",
1300 | "execution_count": null,
1301 | "metadata": {
1302 | "slideshow": {
1303 | "slide_type": "fragment"
1304 | }
1305 | },
1306 | "outputs": [],
1307 | "source": [
1308 | "angka = float(input(\"Masukkan Angka...\"))\n",
1309 | "print(\"Pangkat duanya adalah\", angka**2)\n"
1310 | ]
1311 | },
1312 | {
1313 | "cell_type": "code",
1314 | "execution_count": null,
1315 | "metadata": {
1316 | "slideshow": {
1317 | "slide_type": "fragment"
1318 | }
1319 | },
1320 | "outputs": [],
1321 | "source": [
1322 | "leg_a = float(input(\"Input first leg length: \"))\n",
1323 | "leg_b = float(input(\"Input second leg length: \"))\n",
1324 | "hypo = (leg_a**2 + leg_b**2) ** .5\n",
1325 | "print(\"Hypotenuse length is\", hypo)\n"
1326 | ]
1327 | },
1328 | {
1329 | "cell_type": "code",
1330 | "execution_count": null,
1331 | "metadata": {
1332 | "slideshow": {
1333 | "slide_type": "fragment"
1334 | }
1335 | },
1336 | "outputs": [],
1337 | "source": [
1338 | "fnam = input(\"May I have your first name, please? \")\n",
1339 | "lnam = input(\"May I have your last name, please? \")\n",
1340 | "print(\"Thank you.\")\n",
1341 | "print(\"\\nYour name is \" + fnam + \" \" + lnam + \".\")\n"
1342 | ]
1343 | },
1344 | {
1345 | "cell_type": "code",
1346 | "execution_count": null,
1347 | "metadata": {
1348 | "slideshow": {
1349 | "slide_type": "subslide"
1350 | }
1351 | },
1352 | "outputs": [],
1353 | "source": [
1354 | "#Replication\n",
1355 | "\n",
1356 | "print(\"+\" + 10 * \"-\" + \"+\")\n",
1357 | "print((\"|\" + \" \" * 10 + \"|\\n\") * 5, end=\"\")\n",
1358 | "print(\"+\" + 10 * \"-\" + \"+\")\n"
1359 | ]
1360 | },
1361 | {
1362 | "cell_type": "code",
1363 | "execution_count": null,
1364 | "metadata": {
1365 | "slideshow": {
1366 | "slide_type": "fragment"
1367 | }
1368 | },
1369 | "outputs": [],
1370 | "source": [
1371 | "leg_a = float(input(\"Input first leg length: \"))\n",
1372 | "leg_b = float(input(\"Input second leg length: \"))\n",
1373 | "print(\"Hypotenuse length is \" + str((leg_a**2 + leg_b**2) ** .5))\n"
1374 | ]
1375 | },
1376 | {
1377 | "cell_type": "markdown",
1378 | "metadata": {
1379 | "slideshow": {
1380 | "slide_type": "subslide"
1381 | }
1382 | },
1383 | "source": [
1384 | "### Lab\n",
1385 | "Coba utak atik perintah kode dibawah ini\n",
1386 | "``` python\n",
1387 | "# Masukkan nilai a dalam float\n",
1388 | "# Masukkan nilai b dalam float\n",
1389 | "\n",
1390 | "# hitung hasil penambahan disini\n",
1391 | "# hitung hasil pengurangan disini\n",
1392 | "# hitung hasil perkalian disini\n",
1393 | "# hitung hasil pembagian disini\n",
1394 | "\n",
1395 | "\n",
1396 | "print(\"\\nYeahhhh\")\n",
1397 | "```"
1398 | ]
1399 | },
1400 | {
1401 | "cell_type": "code",
1402 | "execution_count": null,
1403 | "metadata": {
1404 | "slideshow": {
1405 | "slide_type": "subslide"
1406 | }
1407 | },
1408 | "outputs": [],
1409 | "source": [
1410 | "a = float(input(\"Masukkan a = \"))\n",
1411 | "b = float(input(\"Masukkan b = \"))\n",
1412 | "\n",
1413 | "print(\"a+b = \",a+b)\n",
1414 | "print(\"a-b = \",a-b)\n",
1415 | "print(\"a*b = \",a*b)\n",
1416 | "print(\"a/b = \",a/b)\n",
1417 | "print(\"\\nYeahhhh!\")\n"
1418 | ]
1419 | },
1420 | {
1421 | "cell_type": "markdown",
1422 | "metadata": {
1423 | "slideshow": {
1424 | "slide_type": "subslide"
1425 | }
1426 | },
1427 | "source": [
1428 | "### Lab\n",
1429 | "Kerjakan rumus berikut:\n",
1430 | "\n",
1431 | "$$\\frac{1}{x+\\frac{1}{x+\\frac{1}{x+\\frac{1}{x}}}}$$\n",
1432 | "\n",
1433 | "input/output yang diharapkan\n",
1434 | "```python\n",
1435 | "x = 1\n",
1436 | "y = 0.6000000000000001\n",
1437 | "\n",
1438 | "x = 10\n",
1439 | "y = 0.09901951266867294\n",
1440 | "```"
1441 | ]
1442 | },
1443 | {
1444 | "cell_type": "code",
1445 | "execution_count": null,
1446 | "metadata": {
1447 | "slideshow": {
1448 | "slide_type": "fragment"
1449 | }
1450 | },
1451 | "outputs": [],
1452 | "source": [
1453 | "x = float(input(\"Enter value for x: \"))\n",
1454 | "y = 1/(x+1/(x+1/(x+1/x)))\n",
1455 | "\n",
1456 | "print(\"y =\", y)\n"
1457 | ]
1458 | },
1459 | {
1460 | "cell_type": "markdown",
1461 | "metadata": {
1462 | "slideshow": {
1463 | "slide_type": "subslide"
1464 | }
1465 | },
1466 | "source": [
1467 | "### Lab\n",
1468 | "Tugasmu adalah mempersiapkan kode simpel untuk menentukan waktu akhir/selesai sebuah kegiatan. Diberikan variabel durasi waktu dalam menit dan waktu mulai dalam jam (0..23)dan menit (0..59). hasilnya harus dicetak dalam console\n",
1469 | "\n",
1470 | "sebagai contoh, jika suatu kegiatan dimulai pukul `12:17` dan berlangsung selama `59 minutes` , maka kegiatan tersebut tersebut akan selesai pukul `13:16`\n",
1471 | "\n",
1472 | "jangan takut kalau kodemu belum sempurna, tidak masalah waktunya terlihat tidak valid, yang terpenting kodenya dapat menghasilkan nilai yang valid berdasarkan data input.\n",
1473 | "\n",
1474 | "Kode Dasar:\n",
1475 | "```python\n",
1476 | "jam = int(input(\"waktu mulai (jam): \"))\n",
1477 | "menit = int(input(\"waktu mulai (menit): \"))\n",
1478 | "durasi= int(input(\"durasi kegiatan (minutes): \"))\n",
1479 | "\n",
1480 | "# Letakkan kodemu disini\n",
1481 | "```\n",
1482 | "Uji Kodemu, Petunjuk ! gunakan operator % sebagai kunci suksesmu\n",
1483 | ",,"
1484 | ]
1485 | },
1486 | {
1487 | "cell_type": "code",
1488 | "execution_count": null,
1489 | "metadata": {
1490 | "slideshow": {
1491 | "slide_type": "subslide"
1492 | }
1493 | },
1494 | "outputs": [],
1495 | "source": [
1496 | "# coba di cek lagi\n",
1497 | "\n",
1498 | "jam = int(input(\"waktu mulai (jam): \"))\n",
1499 | "menit = int(input(\"waktu mulai (menit): \"))\n",
1500 | "durasi = int(input(\"durasi kegiatan (menit): \"))\n",
1501 | "\n",
1502 | "tambah_menit = menit + durasi\n",
1503 | "tambah_jam = int(tambah_menit / 60)\n",
1504 | "\n",
1505 | "jam += tambah_jam\n",
1506 | "menit = tambah_menit % 60\n",
1507 | "\n",
1508 | "print(str(jam%24)+':'+str(menit))"
1509 | ]
1510 | }
1511 | ],
1512 | "metadata": {
1513 | "celltoolbar": "Slideshow",
1514 | "kernelspec": {
1515 | "display_name": "Python 3",
1516 | "language": "python",
1517 | "name": "python3"
1518 | },
1519 | "language_info": {
1520 | "codemirror_mode": {
1521 | "name": "ipython",
1522 | "version": 3
1523 | },
1524 | "file_extension": ".py",
1525 | "mimetype": "text/x-python",
1526 | "name": "python",
1527 | "nbconvert_exporter": "python",
1528 | "pygments_lexer": "ipython3",
1529 | "version": "3.7.4"
1530 | },
1531 | "rise": {
1532 | "auto_select": "none",
1533 | "auto_select_fragment": false,
1534 | "footer": "netacad Indonesia
",
1535 | "header": "Python - PCAP
",
1536 | "scroll": true,
1537 | "theme": "sky",
1538 | "width": "90%"
1539 | }
1540 | },
1541 | "nbformat": 4,
1542 | "nbformat_minor": 2
1543 | }
--------------------------------------------------------------------------------
/Modul_6_OOP_and_file_operation.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "nbformat": 4,
3 | "nbformat_minor": 0,
4 | "metadata": {
5 | "celltoolbar": "Slideshow",
6 | "kernelspec": {
7 | "display_name": "Python 3",
8 | "language": "python",
9 | "name": "python3"
10 | },
11 | "language_info": {
12 | "codemirror_mode": {
13 | "name": "ipython",
14 | "version": 3
15 | },
16 | "file_extension": ".py",
17 | "mimetype": "text/x-python",
18 | "name": "python",
19 | "nbconvert_exporter": "python",
20 | "pygments_lexer": "ipython3",
21 | "version": "3.7.4"
22 | },
23 | "rise": {
24 | "auto_select": "none",
25 | "auto_select_fragment": false,
26 | "scroll": true,
27 | "theme": "serif",
28 | "width": "90%"
29 | },
30 | "colab": {
31 | "name": "Python OOP .ipynb",
32 | "provenance": [],
33 | "toc_visible": true,
34 | "include_colab_link": true
35 | }
36 | },
37 | "cells": [
38 | {
39 | "cell_type": "markdown",
40 | "metadata": {
41 | "id": "view-in-github",
42 | "colab_type": "text"
43 | },
44 | "source": [
45 | "![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\")
"
46 | ]
47 | },
48 | {
49 | "cell_type": "markdown",
50 | "metadata": {
51 | "id": "v1glAk2VJek9",
52 | "colab_type": "text"
53 | },
54 | "source": [
55 | "# Pemrograman Berbasis Obyek \n",
56 | "\n",
57 | "
\n",
58 | "
\n",
59 | "
\n",
60 | "\n",
61 | "\n",
62 | "\n",
63 | "## OA-DTS Python 2020\n",
64 | "#### Dr. Syukron Abu Ishaq Alfarozi\n"
65 | ]
66 | },
67 | {
68 | "cell_type": "markdown",
69 | "metadata": {
70 | "id": "8b2SFmZUJek_",
71 | "colab_type": "text"
72 | },
73 | "source": [
74 | "# Pemrograman Berbasis Obyek (PBO) a.k.a. OOP\n",
75 | "\n",
76 | "Konsep dari OOP dalam python ini berfokus dalam pembuatan kode yang reusable (dapat digunakan kembali). Konsep ini juga dikenal dengan DRY (Don't Repeat Yourself).\n",
77 | "\n",
78 | "Dalam python, konsep OOP memiliki beberapa prinsip dasar:\n",
79 | "\n",
80 | "| Sifat | Deskripsi |\n",
81 | "|---------------|---------------------------------------------------------------------------------|\n",
82 | "| Inheritance | Proses dalam menggunakan atribut dan behaviour dari class yang telah ada sebelumnya. |\n",
83 | "| Encapsulation* | Menyembunyikan atribut dan behavior yang bersifat private dari kelas lainnya. |\n",
84 | "| Polymorphism* | Sebuah konsep untuk menggunakan operasi yang sama dengan cara yang berbeda pada kelas lain. |\n",
85 | "\n",
86 | "Konsep ini akan terlihat lebih mudah dalam prakteknya nanti"
87 | ]
88 | },
89 | {
90 | "cell_type": "markdown",
91 | "metadata": {
92 | "id": "ZbSOm3mhJelB",
93 | "colab_type": "text"
94 | },
95 | "source": [
96 | "## Function vs Method\n",
97 | "\n",
98 | "* Fungsi : Sebuah prosedur untuk mengolah masukan menjadi keluaran.\n",
99 | "* Method : Sebuah fungsi yang menempel di suatu Object yang bisa (tidak harus) merubah object tersebut.\n",
100 | "\n",
101 | "### Coba perhatikan contoh di bawah ini:"
102 | ]
103 | },
104 | {
105 | "cell_type": "code",
106 | "metadata": {
107 | "id": "WXJXNTWkJelC",
108 | "colab_type": "code",
109 | "colab": {}
110 | },
111 | "source": [
112 | "ls = [3,2,1,4,5,7,8,0]\n",
113 | "print('ls terurut\\t:',sorted(ls))\n",
114 | "print('ls tidak urut\\t:', ls)\n",
115 | "\n",
116 | "ls2 = [3,2,1,4,5,7,8,0]\n",
117 | "ls2.sort()\n",
118 | "print('ls2 terutut\\t:',ls2)"
119 | ],
120 | "execution_count": 0,
121 | "outputs": []
122 | },
123 | {
124 | "cell_type": "markdown",
125 | "metadata": {
126 | "id": "Re058XbIJelH",
127 | "colab_type": "text"
128 | },
129 | "source": [
130 | "## Class and Inheritance\n",
131 | "\n",
132 | "Class adalah sebuah blueprint/konsep dari suatu objek.\n",
133 | "\n"
134 | ]
135 | },
136 | {
137 | "cell_type": "markdown",
138 | "metadata": {
139 | "cell_style": "split",
140 | "id": "q6LFiqjqJelJ",
141 | "colab_type": "text"
142 | },
143 | "source": [
144 | "### Inheritance (Pewarisan sifat)\n",
145 | "\n",
146 | "* `superclass/Parent` lebih bersifat umum dari pada `subclass`.\n",
147 | "* `subclass` mewarisi sifat dari `superclass/Parent` \n",
148 | "\n",
149 | ""
150 | ]
151 | },
152 | {
153 | "cell_type": "markdown",
154 | "metadata": {
155 | "cell_style": "split",
156 | "id": "fu9rAwT-JelK",
157 | "colab_type": "text"
158 | },
159 | "source": [
160 | "
\n",
161 | "
\n",
162 | "
\n",
163 | "\n",
164 | "\n",
165 | ""
166 | ]
167 | },
168 | {
169 | "cell_type": "code",
170 | "metadata": {
171 | "cell_style": "split",
172 | "id": "5gmFkM38JelL",
173 | "colab_type": "code",
174 | "colab": {}
175 | },
176 | "source": [
177 | "# Contoh pendifinisian class\n",
178 | "\n",
179 | "class Hewan:\n",
180 | " def __init__(self,nama):\n",
181 | " self.nama = nama\n",
182 | " def gerak(self):\n",
183 | " print('gerak-gerak!!!')\n",
184 | "\n",
185 | "class HewanDarat(Hewan):\n",
186 | " def __init__(self,nama,kaki=0):\n",
187 | " super().__init__(nama) # Inheritence\n",
188 | " self.kaki = kaki # properti/sifat baru\n",
189 | " \n",
190 | " def gerak(self): # Polymorphism\n",
191 | " print(self.nama,'gerak di darat dengan kaki',self.kaki)\n",
192 | "\n",
193 | "class HewanAir(Hewan):\n",
194 | " def __init__(self,nama,sirip='kecil'):\n",
195 | " super().__init__(nama) # Inheritence\n",
196 | " self.sirip = sirip # properti/sifat baru\n",
197 | " \n",
198 | " def gerak(self): # Polymorphism\n",
199 | " print(self.nama,'gerak di air dengan sirip', self.sirip)\n",
200 | "\n"
201 | ],
202 | "execution_count": 0,
203 | "outputs": []
204 | },
205 | {
206 | "cell_type": "code",
207 | "metadata": {
208 | "cell_style": "split",
209 | "id": "9NembN9UJelP",
210 | "colab_type": "code",
211 | "colab": {}
212 | },
213 | "source": [
214 | "hewan = Hewan('pokoknya hewan')\n",
215 | "kambing = HewanDarat('kambing',kaki=4)\n",
216 | "hiu = HewanAir('hiu',sirip='lebar')\n",
217 | "\n",
218 | "hewan.gerak()\n",
219 | "kambing.gerak()\n",
220 | "hiu.gerak()\n"
221 | ],
222 | "execution_count": 0,
223 | "outputs": []
224 | },
225 | {
226 | "cell_type": "markdown",
227 | "metadata": {
228 | "id": "Y2P7fZUyJelS",
229 | "colab_type": "text"
230 | },
231 | "source": [
232 | "## Enkapsulasi\n",
233 | "\n",
234 | "Menyembunyikan atribut dan behavior yang bersifat private dari kelas lainnya.\n",
235 | "Enkapsulasi di python sangat sederhana, menyembunyikan atribut (tidak sepenuhnya) yaitu dengan menggunakan `__` (dua garis bawah) di awal penamaan atribut.\n",
236 | "\n",
237 | "> Di bahasa pemrograman yang lain mungkin anda akan menemukan hal yang lebih kompleks, cth: `public`,`virtual`, `private`, `protected`.\n",
238 | "\n"
239 | ]
240 | },
241 | {
242 | "cell_type": "code",
243 | "metadata": {
244 | "cell_style": "split",
245 | "id": "B0e6TwquJelT",
246 | "colab_type": "code",
247 | "colab": {}
248 | },
249 | "source": [
250 | "stack = []\n",
251 | "\n",
252 | "def push(val):\n",
253 | " stack.append(val)\n",
254 | "\n",
255 | "\n",
256 | "def pop():\n",
257 | " val = stack[-1]\n",
258 | " del stack[-1]\n",
259 | " return val\n",
260 | "\n",
261 | "push(3)\n",
262 | "push(2)\n",
263 | "push(1)\n",
264 | "\n",
265 | "print(pop())\n",
266 | "print(pop())\n",
267 | "print(pop())"
268 | ],
269 | "execution_count": 0,
270 | "outputs": []
271 | },
272 | {
273 | "cell_type": "code",
274 | "metadata": {
275 | "cell_style": "split",
276 | "id": "hxevKJydJelW",
277 | "colab_type": "code",
278 | "colab": {}
279 | },
280 | "source": [
281 | "class Stack:\n",
282 | " def __init__(self):\n",
283 | " self.stackList = []\n",
284 | "\n",
285 | "stackObject = Stack()\n",
286 | "print(len(stackObject.stackList))\n"
287 | ],
288 | "execution_count": 0,
289 | "outputs": []
290 | },
291 | {
292 | "cell_type": "code",
293 | "metadata": {
294 | "cell_style": "split",
295 | "id": "N0IggmFVJela",
296 | "colab_type": "code",
297 | "colab": {}
298 | },
299 | "source": [
300 | "class Stack:\n",
301 | " def __init__(self):\n",
302 | " self.__stackList = [] # __ membuat private\n",
303 | "\n",
304 | "stackObject = Stack()\n",
305 | "print(len(stackObject.__stackList))"
306 | ],
307 | "execution_count": 0,
308 | "outputs": []
309 | },
310 | {
311 | "cell_type": "code",
312 | "metadata": {
313 | "cell_style": "split",
314 | "id": "_2AIqa50Jele",
315 | "colab_type": "code",
316 | "colab": {}
317 | },
318 | "source": [
319 | "class Stack:\n",
320 | " def __init__(self):\n",
321 | " self.__stackList = []\n",
322 | "\n",
323 | " def push(self, val):\n",
324 | " self.__stackList.append(val)\n",
325 | "\n",
326 | " def pop(self):\n",
327 | " val = self.__stackList[-1]\n",
328 | " del self.__stackList[-1]\n",
329 | " return val\n",
330 | "\n",
331 | "littleStack = Stack()\n",
332 | "anotherStack = Stack()\n",
333 | "funnyStack = Stack()\n",
334 | "\n",
335 | "littleStack.push(1)\n",
336 | "anotherStack.push(littleStack.pop() + 1)\n",
337 | "funnyStack.push(anotherStack.pop() - 2)\n",
338 | "\n",
339 | "print(funnyStack.pop()) "
340 | ],
341 | "execution_count": 0,
342 | "outputs": []
343 | },
344 | {
345 | "cell_type": "code",
346 | "metadata": {
347 | "cell_style": "split",
348 | "id": "XrDxE2ZeJelh",
349 | "colab_type": "code",
350 | "colab": {}
351 | },
352 | "source": [
353 | "class AddingStack(Stack):\n",
354 | " def __init__(self):\n",
355 | " Stack.__init__(self)\n",
356 | " self.__sum = 0\n",
357 | "\n",
358 | " def getSum(self):\n",
359 | " return self.__sum\n",
360 | "\n",
361 | " def push(self, val):\n",
362 | " self.__sum += val\n",
363 | " Stack.push(self, val)\n",
364 | "\n",
365 | " def pop(self):\n",
366 | " val = Stack.pop(self)\n",
367 | " self.__sum -= val\n",
368 | " return val\n",
369 | "\n",
370 | "\n",
371 | "stackObject = AddingStack()\n",
372 | "\n",
373 | "for i in range(5):\n",
374 | " stackObject.push(i)\n",
375 | "print(stackObject.getSum())\n",
376 | "\n",
377 | "for i in range(5):\n",
378 | " print(stackObject.pop())"
379 | ],
380 | "execution_count": 0,
381 | "outputs": []
382 | },
383 | {
384 | "cell_type": "markdown",
385 | "metadata": {
386 | "cell_style": "split",
387 | "id": "q9ij6A4oJelj",
388 | "colab_type": "text"
389 | },
390 | "source": [
391 | "### Properties and method:\n",
392 | "```python\n",
393 | "cls.__dict__\n",
394 | "cls.__name__\n",
395 | "cls.__module__\n",
396 | "hasattr(cls,'str')\n",
397 | "getattr(cls, 'str')\n",
398 | "setattr(cls,'str')\n",
399 | "cls is cls\n",
400 | "issubclass(ClassOne, ClassTwo)\n",
401 | "isinstance(objectName, ClassName)\n",
402 | "cls.__str__() \n",
403 | "```\n"
404 | ]
405 | },
406 | {
407 | "cell_type": "code",
408 | "metadata": {
409 | "cell_style": "split",
410 | "id": "2vgeLlOFJelj",
411 | "colab_type": "code",
412 | "colab": {}
413 | },
414 | "source": [
415 | "# Let's code\n",
416 | "# Python is hackable"
417 | ],
418 | "execution_count": 0,
419 | "outputs": []
420 | },
421 | {
422 | "cell_type": "markdown",
423 | "metadata": {
424 | "id": "vhc4wBzAJelm",
425 | "colab_type": "text"
426 | },
427 | "source": [
428 | "## Multiple Inheritance"
429 | ]
430 | },
431 | {
432 | "cell_type": "code",
433 | "metadata": {
434 | "id": "Lz1Hso6hJelm",
435 | "colab_type": "code",
436 | "colab": {}
437 | },
438 | "source": [
439 | "class Left:\n",
440 | " var = \"L\"\n",
441 | " varLeft = \"LL\"\n",
442 | " def fun(self):\n",
443 | " return \"Left\"\n",
444 | "\n",
445 | "\n",
446 | "class Right:\n",
447 | " var = \"R\"\n",
448 | " varRight = \"RR\"\n",
449 | " def fun(self):\n",
450 | " return \"Right\"\n",
451 | "\n",
452 | "class Sub(Left, Right):\n",
453 | " pass\n",
454 | "\n",
455 | "\n",
456 | "obj = Sub()\n",
457 | "\n",
458 | "print(obj.var, obj.varLeft, obj.varRight, obj.fun())"
459 | ],
460 | "execution_count": 0,
461 | "outputs": []
462 | },
463 | {
464 | "cell_type": "markdown",
465 | "metadata": {
466 | "id": "plh19QJ3Jelo",
467 | "colab_type": "text"
468 | },
469 | "source": [
470 | "## Exception again"
471 | ]
472 | },
473 | {
474 | "cell_type": "code",
475 | "metadata": {
476 | "cell_style": "split",
477 | "id": "fNu-nWx4Jelp",
478 | "colab_type": "code",
479 | "colab": {}
480 | },
481 | "source": [
482 | "def reciprocal(n):\n",
483 | " try:\n",
484 | " n = 1 / n\n",
485 | " except ZeroDivisionError:\n",
486 | " print(\"Division failed\")\n",
487 | " n = None\n",
488 | " else:\n",
489 | " print(\"Everything went fine\")\n",
490 | " finally:\n",
491 | " print(\"It's time to say goodbye\")\n",
492 | " return n\n",
493 | "\n",
494 | "print(reciprocal(2))\n",
495 | "print(reciprocal(0))"
496 | ],
497 | "execution_count": 0,
498 | "outputs": []
499 | },
500 | {
501 | "cell_type": "code",
502 | "metadata": {
503 | "cell_style": "split",
504 | "id": "XgkMMSnpJelr",
505 | "colab_type": "code",
506 | "colab": {}
507 | },
508 | "source": [
509 | "try:\n",
510 | " i = int(\"Hello!\")\n",
511 | "except Exception as e:\n",
512 | " print(e)\n",
513 | " print(e.__str__())"
514 | ],
515 | "execution_count": 0,
516 | "outputs": []
517 | },
518 | {
519 | "cell_type": "code",
520 | "metadata": {
521 | "id": "_mJWYItaJelt",
522 | "colab_type": "code",
523 | "colab": {}
524 | },
525 | "source": [
526 | "def printExcTree(thisclass, nest = 0):\n",
527 | " if nest > 1:\n",
528 | " print(\" |\" * (nest - 1), end=\"\")\n",
529 | " if nest > 0:\n",
530 | " print(\" +---\", end=\"\")\n",
531 | "\n",
532 | " print(thisclass.__name__)\n",
533 | "\n",
534 | " for subclass in thisclass.__subclasses__():\n",
535 | " printExcTree(subclass, nest + 1)\n",
536 | "\n",
537 | "printExcTree(BaseException)"
538 | ],
539 | "execution_count": 0,
540 | "outputs": []
541 | },
542 | {
543 | "cell_type": "code",
544 | "metadata": {
545 | "id": "ix4CfK2AJelv",
546 | "colab_type": "code",
547 | "colab": {}
548 | },
549 | "source": [
550 | "try:\n",
551 | "\traise Exception(\"my exception\")\n",
552 | "except Exception as e:\n",
553 | "\tprint(e, e.__str__(), sep=' : ', end=' : ')\n",
554 | "\tprint(e.args)\n"
555 | ],
556 | "execution_count": 0,
557 | "outputs": []
558 | },
559 | {
560 | "cell_type": "markdown",
561 | "metadata": {
562 | "id": "-wrpvpD4Jely",
563 | "colab_type": "text"
564 | },
565 | "source": [
566 | "## Generator"
567 | ]
568 | },
569 | {
570 | "cell_type": "code",
571 | "metadata": {
572 | "cell_style": "split",
573 | "id": "wminT93KJely",
574 | "colab_type": "code",
575 | "colab": {}
576 | },
577 | "source": [
578 | "class Fib:\n",
579 | "\tdef __init__(self, nn):\n",
580 | "\t\tself.__n = nn\n",
581 | "\t\tself.__i = 0\n",
582 | "\t\tself.__p1 = self.__p2 = 1\n",
583 | "\n",
584 | "\tdef __iter__(self):\n",
585 | "\t\tprint(\"Fib iter\")\n",
586 | "\t\treturn self\n",
587 | "\n",
588 | "\tdef __next__(self):\n",
589 | "\t\tself.__i += 1\n",
590 | "\t\tif self.__i > self.__n:\n",
591 | "\t\t\traise StopIteration\n",
592 | "\t\tif self.__i in [1, 2]:\n",
593 | "\t\t\treturn 1\n",
594 | "\t\tret = self.__p1 + self.__p2\n",
595 | "\t\tself.__p1, self.__p2 = self.__p2, ret\n",
596 | "\t\treturn ret\n",
597 | "\n",
598 | "\n"
599 | ],
600 | "execution_count": 0,
601 | "outputs": []
602 | },
603 | {
604 | "cell_type": "code",
605 | "metadata": {
606 | "cell_style": "split",
607 | "id": "XClbZp4UJel0",
608 | "colab_type": "code",
609 | "colab": {}
610 | },
611 | "source": [
612 | "\n",
613 | "for i in Fib(10):\n",
614 | "\tprint(i)\n",
615 | " "
616 | ],
617 | "execution_count": 0,
618 | "outputs": []
619 | },
620 | {
621 | "cell_type": "code",
622 | "metadata": {
623 | "cell_style": "split",
624 | "id": "XYrIC3TVJel4",
625 | "colab_type": "code",
626 | "colab": {}
627 | },
628 | "source": [
629 | "# Yield\n",
630 | "\n",
631 | "def fun(n):\n",
632 | " for i in range(n):\n",
633 | " yield i\n",
634 | "\n",
635 | "# Lambda\n",
636 | "# lambda parameters : expression\n",
637 | "\n",
638 | "two = lambda : 2\n",
639 | "sqr = lambda x : x * x\n",
640 | "pwr = lambda x, y : x ** y\n"
641 | ],
642 | "execution_count": 0,
643 | "outputs": []
644 | },
645 | {
646 | "cell_type": "code",
647 | "metadata": {
648 | "cell_style": "split",
649 | "id": "QRHB3hidJel7",
650 | "colab_type": "code",
651 | "colab": {}
652 | },
653 | "source": [
654 | "for i in fun(5):\n",
655 | " print(i)\n",
656 | "\n",
657 | "for a in range(-2, 3):\n",
658 | " print(sqr(a), end=\" \")\n",
659 | " print(pwr(a, two()))"
660 | ],
661 | "execution_count": 0,
662 | "outputs": []
663 | },
664 | {
665 | "cell_type": "code",
666 | "metadata": {
667 | "cell_style": "split",
668 | "id": "sfe_C8VnJel-",
669 | "colab_type": "code",
670 | "colab": {}
671 | },
672 | "source": [
673 | "# Map and filter\n",
674 | "\n",
675 | "from random import seed, randint\n",
676 | "\n",
677 | "#map\n",
678 | "list1 = [x for x in range(5)]\n",
679 | "list2 = list(map(lambda x: 2 ** x, list1))\n",
680 | "\n",
681 | "#filter\n",
682 | "seed(0)\n",
683 | "data = [ randint(-10,10) for x in range(5) ]\n",
684 | "filtered = list(filter(lambda x: x > 0 and x % 2 == 0, data))\n"
685 | ],
686 | "execution_count": 0,
687 | "outputs": []
688 | },
689 | {
690 | "cell_type": "code",
691 | "metadata": {
692 | "cell_style": "split",
693 | "id": "WTLbsO9zJemA",
694 | "colab_type": "code",
695 | "colab": {}
696 | },
697 | "source": [
698 | "print(list1)\n",
699 | "print(list2)\n",
700 | "print(data)\n",
701 | "print(filtered)"
702 | ],
703 | "execution_count": 0,
704 | "outputs": []
705 | },
706 | {
707 | "cell_type": "markdown",
708 | "metadata": {
709 | "id": "8hJwC66nJemC",
710 | "colab_type": "text"
711 | },
712 | "source": [
713 | "## Closure\n",
714 | "Let's start with a definition: closure is a technique which allows the storing of values in spite of the fact that the context in which they have been created does not exist anymore. "
715 | ]
716 | },
717 | {
718 | "cell_type": "code",
719 | "metadata": {
720 | "id": "PacwmzpFJemD",
721 | "colab_type": "code",
722 | "colab": {}
723 | },
724 | "source": [
725 | "def outer(par):\n",
726 | "\tloc = par\n",
727 | "\tdef inner():\n",
728 | "\t\treturn loc\n",
729 | "\treturn inner\n",
730 | "\n",
731 | "var = 1\n",
732 | "fun = outer(var)\n",
733 | "print(fun())"
734 | ],
735 | "execution_count": 0,
736 | "outputs": []
737 | },
738 | {
739 | "cell_type": "markdown",
740 | "metadata": {
741 | "id": "O-iSAmWFJemG",
742 | "colab_type": "text"
743 | },
744 | "source": [
745 | "## Partial functional tools"
746 | ]
747 | },
748 | {
749 | "cell_type": "code",
750 | "metadata": {
751 | "id": "qQ9qrrM5JemG",
752 | "colab_type": "code",
753 | "colab": {}
754 | },
755 | "source": [
756 | "from functools import partial \n",
757 | "\n",
758 | "# A normal function \n",
759 | "def f(a, b, c, x): \n",
760 | " return 1000*a + 100*b + 10*c + x \n",
761 | " \n",
762 | "# A partial function that calls f with \n",
763 | "# a as 3, b as 1 and c as 4. \n",
764 | "g = partial(f, 3, 1, 4) \n",
765 | " \n",
766 | "# Calling g() \n",
767 | "print(g(5)) "
768 | ],
769 | "execution_count": 0,
770 | "outputs": []
771 | },
772 | {
773 | "cell_type": "markdown",
774 | "metadata": {
775 | "cell_style": "split",
776 | "id": "5n2YcXh4JemJ",
777 | "colab_type": "text"
778 | },
779 | "source": [
780 | "## Working with files\n",
781 | "\n",
782 | "file mode:\n",
783 | "\n",
784 | "\n",
785 | "\n",
786 | "|Text mode |\tBinary mode |\tDescription|\n",
787 | "|-----------|-----------------|-------------|\n",
788 | "|rt|\trb|\tread|\n",
789 | "|wt|\twb|\twrite|\n",
790 | "|at\t|ab\t|append|\n",
791 | "|r+t|\tr+b|\tread and update|\n",
792 | "|w+t\t|w+b|\twrite and update|"
793 | ]
794 | },
795 | {
796 | "cell_type": "markdown",
797 | "metadata": {
798 | "cell_style": "split",
799 | "id": "fmu_f6WlJemJ",
800 | "colab_type": "text"
801 | },
802 | "source": [
803 | "### File Methods\n",
804 | "* Read methods\n",
805 | "\n",
806 | "```python\n",
807 | "stream.read(idx)\n",
808 | "stream.readline()\n",
809 | "stream.readlines(n) #multiple lines\n",
810 | "\n",
811 | "```\n",
812 | "\n",
813 | "* write methods\n",
814 | "\n",
815 | "```python\n",
816 | "stream.write(str)\n",
817 | "```"
818 | ]
819 | },
820 | {
821 | "cell_type": "code",
822 | "metadata": {
823 | "id": "8nDtGUlkLICa",
824 | "colab_type": "code",
825 | "colab": {}
826 | },
827 | "source": [
828 | "!wget https://raw.githubusercontent.com/sykrn/py-dts/master/asets/cth.txt"
829 | ],
830 | "execution_count": 0,
831 | "outputs": []
832 | },
833 | {
834 | "cell_type": "code",
835 | "metadata": {
836 | "cell_style": "center",
837 | "id": "84MLw5XpJemK",
838 | "colab_type": "code",
839 | "colab": {}
840 | },
841 | "source": [
842 | "stream = open(\"cth.txt\", \"rt\", encoding = \"utf-8\") # opening tzop.txt in read mode, returning it as a file object\n",
843 | "print(stream.read())\n",
844 | "stream.close()"
845 | ],
846 | "execution_count": 0,
847 | "outputs": []
848 | },
849 | {
850 | "cell_type": "code",
851 | "metadata": {
852 | "id": "rkoRstgPJemO",
853 | "colab_type": "code",
854 | "colab": {}
855 | },
856 | "source": [
857 | "# Read\n",
858 | "from os import strerror\n",
859 | "\n",
860 | "try:\n",
861 | " cnt = 0\n",
862 | " s = open('cth.txt', \"rt\")\n",
863 | " ch = s.read(1)\n",
864 | " while ch != '':\n",
865 | " print(ch, end='')\n",
866 | " cnt += 1\n",
867 | " ch = s.read(1)\n",
868 | " s.close()\n",
869 | " print(\"\\n\\nCharacters in file:\", cnt)\n",
870 | "except IOError as e:\n",
871 | " print(\"I/O error occurred: \", strerr(e.errno))"
872 | ],
873 | "execution_count": 0,
874 | "outputs": []
875 | },
876 | {
877 | "cell_type": "code",
878 | "metadata": {
879 | "id": "uJ4zN-d4JemS",
880 | "colab_type": "code",
881 | "colab": {}
882 | },
883 | "source": [
884 | "#Write\n",
885 | "from os import strerror\n",
886 | "\n",
887 | "try:\n",
888 | "\tfo = open('newtext.txt', 'wt')\n",
889 | "\tfor i in range(10):\n",
890 | "\t\tfo.write(\"line #\" + str(i+1) + \"\\n\")\n",
891 | "\tfo.close()\n",
892 | "except IOError as e:\n",
893 | "\tprint(\"I/O error occurred: \", strerr(e.errno))"
894 | ],
895 | "execution_count": 0,
896 | "outputs": []
897 | },
898 | {
899 | "cell_type": "markdown",
900 | "metadata": {
901 | "id": "dyDIw_j8JemU",
902 | "colab_type": "text"
903 | },
904 | "source": [
905 | "### bytesarray\n"
906 | ]
907 | },
908 | {
909 | "cell_type": "code",
910 | "metadata": {
911 | "id": "pgoCtQ5jJemV",
912 | "colab_type": "code",
913 | "colab": {}
914 | },
915 | "source": [
916 | "data = bytearray(10)\n",
917 | "\n",
918 | "for i in range(len(data)):\n",
919 | " data[i] = 10 - i\n",
920 | "\n",
921 | "for b in data:\n",
922 | " print(hex(b))"
923 | ],
924 | "execution_count": 0,
925 | "outputs": []
926 | },
927 | {
928 | "cell_type": "code",
929 | "metadata": {
930 | "id": "UZNZ94_XJemZ",
931 | "colab_type": "code",
932 | "colab": {}
933 | },
934 | "source": [
935 | "# write\n",
936 | "from os import strerror\n",
937 | "\n",
938 | "data = bytearray(10)\n",
939 | "\n",
940 | "for i in range(len(data)):\n",
941 | " data[i] = 10 + i\n",
942 | "\n",
943 | "try:\n",
944 | " bf = open('file.bin', 'wb')\n",
945 | " bf.write(data)\n",
946 | " bf.close()\n",
947 | "except IOError as e:\n",
948 | " print(\"I/O error occurred:\", strerr(e.errno))\n"
949 | ],
950 | "execution_count": 0,
951 | "outputs": []
952 | },
953 | {
954 | "cell_type": "code",
955 | "metadata": {
956 | "id": "DXEzFsRvJemc",
957 | "colab_type": "code",
958 | "colab": {}
959 | },
960 | "source": [
961 | "#read and write / copy paste script\n",
962 | "from os import strerror\n",
963 | "\n",
964 | "srcname = input(\"Source file name?: \")\n",
965 | "try:\n",
966 | " src = open(srcname, 'rb')\n",
967 | "except IOError as e:\n",
968 | " print(\"Cannot open source file: \", strerror(e.errno))\n",
969 | " exit(e.errno)\t\n",
970 | "dstname = input(\"Destination file name?: \")\n",
971 | "try:\n",
972 | " dst = open(dstname, 'wb')\n",
973 | "except Exception as e:\n",
974 | " print(\"Cannot create destination file: \", strerr(e.errno))\n",
975 | " src.close()\n",
976 | " exit(e.errno)\t\n",
977 | "\n",
978 | "buffer = bytearray(65536)\n",
979 | "total = 0\n",
980 | "try:\n",
981 | " readin = src.readinto(buffer)\n",
982 | " while readin > 0:\n",
983 | " written = dst.write(buffer[:readin])\n",
984 | " total += written\n",
985 | " readin = src.readinto(buffer)\n",
986 | "except IOError as e:\n",
987 | " print(\"Cannot create destination file: \", strerr(e.errno))\n",
988 | " exit(e.errno)\t\n",
989 | " \n",
990 | "print(total,'byte(s) succesfully written')\n",
991 | "src.close()\n",
992 | "dst.close()"
993 | ],
994 | "execution_count": 0,
995 | "outputs": []
996 | }
997 | ]
998 | }
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # dts-kominfo python 2020
2 | Digital Talent Scholarship files
3 | > edited and improved from previous repo: https://github.com/gunturbudi/digital-talent/tree/master/2019
4 |
5 | ## Modules
6 | * Modul 1 - Pengenalan Python dan Bahasa Pemrograman [open colab](https://colab.research.google.com/github/sykrn/py-dts/blob/master/Modul%201%20-%20Pengenalan%20Python%20dan%20Bahasa%20Pemrograman.ipynb)
7 | * Modul 2 - Tipe Data, Variabel, Dasar Input Output [open colab](https://colab.research.google.com/github/sykrn/py-dts/blob/master/Modul%202%20-%20Tipe%20Data%2C%20Variabel%2C%20Dasar%20Input%20Output%2C%20Operasi.ipynb)
8 | * Modul 3 - Operator kondisi, perulangan, list dan operasinya, bitwise, boolean [open colab](https://colab.research.google.com/github/sykrn/py-dts/blob/master/Modul%203%20-%20Operator%20kondisi%2C%20perulangan%2C%20list%20dan%20operasinya%2C%20bitwise%2C%20boolean.ipynb)
9 | * Modul 4 - Function Tuple Dictionaries and Data Processing [open colab](https://colab.research.google.com/github/sykrn/py-dts/blob/master/Modul%204%20-%20Function%20Tuple%20Dictionaries%20and%20Data%20Processing.ipynb)
10 | * Modul 5 - Modules, packages, string and list methods, and exceptions [open colab](https://colab.research.google.com/github/sykrn/py-dts/blob/master/Modul%205%20-%20Modules,%20packages,%20string%20and%20list%20methods,%20and%20exceptions.ipynb)
11 | * Modul 6 - Object Oriented Approach, Exception Handling, Working with Files (update!)
12 |
13 | > Semua modul akan diupdate secara berkala, sesuai jadwal pelatihan. Selamat belajar!
14 |
15 | Cek score project (Kalau sudah dikoreksi) klik link di [sini](https://sykrn.github.io/pydts/).
16 |
17 |
--------------------------------------------------------------------------------
/_config.yml:
--------------------------------------------------------------------------------
1 | theme: jekyll-theme-slate
--------------------------------------------------------------------------------
/asets/colab.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/asets/colab.png
--------------------------------------------------------------------------------
/asets/cth.txt:
--------------------------------------------------------------------------------
1 | Pertama
2 | Kami poetera dan poeteri Indonesia, mengakoe bertoempah darah jang satoe, tanah Indonesia.
3 | Kedoea
4 | Kami poetera dan poeteri Indonesia, mengakoe berbangsa jang satoe, bangsa Indonesia.
5 | Ketiga
6 | Kami poetera dan poeteri Indonesia, mendjoendjoeng bahasa persatoean, bahasa Indonesia.
--------------------------------------------------------------------------------
/asets/diamond.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/asets/diamond.png
--------------------------------------------------------------------------------
/asets/enkrip.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/asets/enkrip.jpg
--------------------------------------------------------------------------------
/asets/filehandle.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/asets/filehandle.png
--------------------------------------------------------------------------------
/asets/filename.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/asets/filename.png
--------------------------------------------------------------------------------
/asets/files.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/asets/files.png
--------------------------------------------------------------------------------
/asets/filestream.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/asets/filestream.png
--------------------------------------------------------------------------------
/asets/inheritance.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/asets/inheritance.png
--------------------------------------------------------------------------------
/asets/iobase.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/asets/iobase.png
--------------------------------------------------------------------------------
/asets/leapyear.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/asets/leapyear.png
--------------------------------------------------------------------------------
/asets/linkaran.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/asets/linkaran.png
--------------------------------------------------------------------------------
/asets/max.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/asets/max.png
--------------------------------------------------------------------------------
/asets/osmodule.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/asets/osmodule.png
--------------------------------------------------------------------------------
/asets/p1_pilot.json:
--------------------------------------------------------------------------------
1 | {
2 | "ihsan@xxxxx": {
3 | "out": [
4 | "letter_catalog :\ncase inputs: ([['Apple', 'Avocado', 'Banana', 'Blackberries', 'Blueberries', 'Cherries']], {'letter': 'A'})\nResults: ['Benar', ['Apple', 'Avocado'], , ['Apple', 'Avocado'], ]\ncase inputs: ([['Apple', 'Avocado', 'Banana', 'Blackberries', 'Blueberries', 'Cherries']], {'letter': 'B'})\nResults: ['Benar', ['Banana', 'Blackberries', 'Blueberries'], , ['Banana', 'Blackberries', 'Blueberries'], ]\ncase inputs: ([['Apple', 'Avocado', 'Banana', 'Blackberries', 'Blueberries', 'Cherries']], {'letter': 'C'})\nResults: ['Benar', ['Cherries'], , ['Cherries'], ]\n",
5 | "counter_item :\ncase inputs: [[['Cherries', 'Blueberries', 'Banana', 'Avocado', 'Blackberries', 'Banana', 'Blueberries', 'Avocado', 'Banana', 'Blackberries']], {}]\nResults: ['Benar', {'Cherries': 1, 'Blueberries': 2, 'Banana': 3, 'Avocado': 2, 'Blackberries': 2}, , {'Cherries': 1, 'Blueberries': 2, 'Banana': 3, 'Avocado': 2, 'Blackberries': 2}, ]\ncase inputs: [[['Cherries', 'Blackberries', 'Avocado', 'Blueberries', 'Blackberries', 'Avocado', 'Cherries', 'Cherries', 'Blueberries', 'Cherries']], {}]\nResults: ['Benar', {'Cherries': 4, 'Blackberries': 2, 'Avocado': 2, 'Blueberries': 2}, , {'Cherries': 4, 'Blackberries': 2, 'Avocado': 2, 'Blueberries': 2}, ]\ncase inputs: [[['Avocado', 'Blueberries', 'Cherries', 'Blueberries', 'Banana', 'Apple', 'Banana', 'Blackberries', 'Cherries', 'Cherries']], {}]\nResults: ['Benar', {'Avocado': 1, 'Blueberries': 2, 'Cherries': 3, 'Banana': 2, 'Apple': 1, 'Blackberries': 1}, , {'Avocado': 1, 'Blueberries': 2, 'Cherries': 3, 'Banana': 2, 'Apple': 1, 'Blackberries': 1}, ]\n",
6 | "fruit_price :\n['Benar', {'Apple': 6, 'Avocado': 5, 'Banana': 3, 'Blackberries': 10, 'Blueberries': 12, 'Cherries': 7, 'Date Fruit': 14, 'Grapes': 15, 'Guava': 8, 'Jackfruit': 7, 'Kiwifruit': 9}, , {'Apple': 6, 'Avocado': 5, 'Banana': 3, 'Blackberries': 10, 'Blueberries': 12, 'Cherries': 7, 'Date Fruit': 14, 'Grapes': 15, 'Guava': 8, 'Jackfruit': 7, 'Kiwifruit': 9}, ]",
7 | "total_price :\ncase inputs: ([{'Cherries': 1, 'Blueberries': 2, 'Banana': 3, 'Avocado': 2, 'Blackberries': 2}, {'Apple': 6, 'Avocado': 5, 'Banana': 3, 'Blackberries': 10, 'Blueberries': 12, 'Cherries': 7, 'Date Fruit': 14, 'Grapes': 15, 'Guava': 8, 'Jackfruit': 7, 'Kiwifruit': 9}], {})\nResults: ['Benar', 70, , 70, ]\ncase inputs: ([{'Cherries': 4, 'Blackberries': 2, 'Avocado': 2, 'Blueberries': 2}, {'Apple': 6, 'Avocado': 5, 'Banana': 3, 'Blackberries': 10, 'Blueberries': 12, 'Cherries': 7, 'Date Fruit': 14, 'Grapes': 15, 'Guava': 8, 'Jackfruit': 7, 'Kiwifruit': 9}], {})\nResults: ['Benar', 82, , 82, ]\ncase inputs: ([{'Avocado': 1, 'Blueberries': 2, 'Cherries': 3, 'Banana': 2, 'Apple': 1, 'Blackberries': 1}, {'Apple': 6, 'Avocado': 5, 'Banana': 3, 'Blackberries': 10, 'Blueberries': 12, 'Cherries': 7, 'Date Fruit': 14, 'Grapes': 15, 'Guava': 8, 'Jackfruit': 7, 'Kiwifruit': 9}], {})\nResults: ['Benar', 72, , 72, ]\n",
8 | "discounted_price :\ncase inputs: [(100, 10), {'minprice': 100}]\nResults: ['Benar', 90.0, , 90.0, ]\ncase inputs: [(110, 10), {'minprice': 80}]\nResults: ['Benar', 99.0, , 99.0, ]\ncase inputs: [(100, 15), {'minprice': 120}]\nResults: ['Benar', 100, , 100, ]\ncase inputs: [(200, 12), {'minprice': 100}]\nResults: ['Benar', 176.0, , 176.0, ]\ncase inputs: [(230, 33), {'minprice': 100}]\nResults: ['Salah', 154.1, , 154.10000000000002, ]\n"
9 | ],
10 | "score": 80.0,
11 | "scores": [
12 | 1.0,
13 | 1.0,
14 | 1,
15 | 1.0,
16 | 0.8
17 | ]
18 | },
19 | "ferdinand.winstein@xxxxx": {
20 | "out": [
21 | "letter_catalog :\ncase inputs: ([['Apple', 'Avocado', 'Banana', 'Blackberries', 'Blueberries', 'Cherries']], {'letter': 'A'})\nResults: ['Benar', ['Apple', 'Avocado'], , ['Apple', 'Avocado'], ]\ncase inputs: ([['Apple', 'Avocado', 'Banana', 'Blackberries', 'Blueberries', 'Cherries']], {'letter': 'B'})\nResults: ['Benar', ['Banana', 'Blackberries', 'Blueberries'], , ['Banana', 'Blackberries', 'Blueberries'], ]\ncase inputs: ([['Apple', 'Avocado', 'Banana', 'Blackberries', 'Blueberries', 'Cherries']], {'letter': 'C'})\nResults: ['Benar', ['Cherries'], , ['Cherries'], ]\n",
22 | "counter_item :\ncase inputs: [[['Cherries', 'Blueberries', 'Banana', 'Avocado', 'Blackberries', 'Banana', 'Blueberries', 'Avocado', 'Banana', 'Blackberries']], {}]\nResults: ['Benar', {'Cherries': 1, 'Blueberries': 2, 'Banana': 3, 'Avocado': 2, 'Blackberries': 2}, , {'Cherries': 1, 'Blueberries': 2, 'Banana': 3, 'Avocado': 2, 'Blackberries': 2}, ]\ncase inputs: [[['Cherries', 'Blackberries', 'Avocado', 'Blueberries', 'Blackberries', 'Avocado', 'Cherries', 'Cherries', 'Blueberries', 'Cherries']], {}]\nResults: ['Benar', {'Cherries': 4, 'Blackberries': 2, 'Avocado': 2, 'Blueberries': 2}, , {'Cherries': 4, 'Blackberries': 2, 'Avocado': 2, 'Blueberries': 2}, ]\ncase inputs: [[['Avocado', 'Blueberries', 'Cherries', 'Blueberries', 'Banana', 'Apple', 'Banana', 'Blackberries', 'Cherries', 'Cherries']], {}]\nResults: ['Benar', {'Avocado': 1, 'Blueberries': 2, 'Cherries': 3, 'Banana': 2, 'Apple': 1, 'Blackberries': 1}, , {'Avocado': 1, 'Blueberries': 2, 'Cherries': 3, 'Banana': 2, 'Apple': 1, 'Blackberries': 1}, ]\n",
23 | "fruit_price :\n['Benar', {'Apple': 6, 'Avocado': 5, 'Banana': 3, 'Blackberries': 10, 'Blueberries': 12, 'Cherries': 7, 'Date Fruit': 14, 'Grapes': 15, 'Guava': 8, 'Jackfruit': 7, 'Kiwifruit': 9}, , {'Apple': 6, 'Avocado': 5, 'Banana': 3, 'Blackberries': 10, 'Blueberries': 12, 'Cherries': 7, 'Date Fruit': 14, 'Grapes': 15, 'Guava': 8, 'Jackfruit': 7, 'Kiwifruit': 9}, ]",
24 | "total_price :\ncase inputs: ([{'Cherries': 1, 'Blueberries': 2, 'Banana': 3, 'Avocado': 2, 'Blackberries': 2}, {'Apple': 6, 'Avocado': 5, 'Banana': 3, 'Blackberries': 10, 'Blueberries': 12, 'Cherries': 7, 'Date Fruit': 14, 'Grapes': 15, 'Guava': 8, 'Jackfruit': 7, 'Kiwifruit': 9}], {})\nResults: ['Benar', 70, , 70, ]\ncase inputs: ([{'Cherries': 4, 'Blackberries': 2, 'Avocado': 2, 'Blueberries': 2}, {'Apple': 6, 'Avocado': 5, 'Banana': 3, 'Blackberries': 10, 'Blueberries': 12, 'Cherries': 7, 'Date Fruit': 14, 'Grapes': 15, 'Guava': 8, 'Jackfruit': 7, 'Kiwifruit': 9}], {})\nResults: ['Benar', 82, , 82, ]\ncase inputs: ([{'Avocado': 1, 'Blueberries': 2, 'Cherries': 3, 'Banana': 2, 'Apple': 1, 'Blackberries': 1}, {'Apple': 6, 'Avocado': 5, 'Banana': 3, 'Blackberries': 10, 'Blueberries': 12, 'Cherries': 7, 'Date Fruit': 14, 'Grapes': 15, 'Guava': 8, 'Jackfruit': 7, 'Kiwifruit': 9}], {})\nResults: ['Benar', 72, , 72, ]\n",
25 | "discounted_price :\ncase inputs: [(100, 10), {'minprice': 100}]\nResults: ['Salah', 90.0, , 100, ]\ncase inputs: [(110, 10), {'minprice': 80}]\nResults: ['Benar', 99.0, , 99.0, ]\ncase inputs: [(100, 15), {'minprice': 120}]\nResults: ['Benar', 100, , 100, ]\ncase inputs: [(200, 12), {'minprice': 100}]\nResults: ['Benar', 176.0, , 176.0, ]\ncase inputs: [(230, 33), {'minprice': 100}]\nResults: ['Benar', 154.1, , 154.1, ]\n",
26 | "print_summary :\ncase inputs: [[['Banana', 'Cherries', 'Avocado', 'Blueberries', 'Blackberries', 'Apple', 'Blueberries', 'Banana', 'Blueberries', 'Blueberries'], {'Apple': 6, 'Avocado': 5, 'Banana': 3, 'Blackberries': 10, 'Blueberries': 12, 'Cherries': 7, 'Date Fruit': 14, 'Grapes': 15, 'Guava': 8, 'Jackfruit': 7, 'Kiwifruit': 9}], {}]\nResults: ['Salah', '1 Apple : 6\\n1 Avocado : 5\\n2 Banana : 6\\n1 Blackberries : 10\\n4 Blueberries : 48\\n1 Cherries : 7\\ntotal : 82\\ndiscount price : 82\\n', , '2 Banana : 6\\n1 Cherries : 7\\n1 Avocado : 5\\n4 Blueberries : 48\\n1 Blackberries : 10\\n1 Apple : 6\\ntotal : 82\\ndiscount price : 82\\n', ]\ncase inputs: [[['Apple', 'Banana', 'Cherries', 'Avocado', 'Avocado', 'Cherries', 'Avocado', 'Blackberries', 'Avocado', 'Cherries'], {'Apple': 6, 'Avocado': 5, 'Banana': 3, 'Blackberries': 10, 'Blueberries': 12, 'Cherries': 7, 'Date Fruit': 14, 'Grapes': 15, 'Guava': 8, 'Jackfruit': 7, 'Kiwifruit': 9}], {}]\nResults: ['Salah', '1 Apple : 6\\n4 Avocado : 20\\n1 Banana : 3\\n1 Blackberries : 10\\n3 Cherries : 21\\ntotal : 60\\ndiscount price : 60\\n', , '1 Apple : 6\\n1 Banana : 3\\n3 Cherries : 21\\n4 Avocado : 20\\n1 Blackberries : 10\\ntotal : 60\\ndiscount price : 60\\n', ]\ncase inputs: [[['Blueberries', 'Banana', 'Apple', 'Avocado', 'Blackberries', 'Cherries', 'Apple', 'Blackberries', 'Blueberries', 'Blackberries'], {'Apple': 6, 'Avocado': 5, 'Banana': 3, 'Blackberries': 10, 'Blueberries': 12, 'Cherries': 7, 'Date Fruit': 14, 'Grapes': 15, 'Guava': 8, 'Jackfruit': 7, 'Kiwifruit': 9}], {}]\nResults: ['Salah', '2 Apple : 12\\n1 Avocado : 5\\n1 Banana : 3\\n3 Blackberries : 30\\n2 Blueberries : 24\\n1 Cherries : 7\\ntotal : 81\\ndiscount price : 81\\n', , '2 Blueberries : 24\\n1 Banana : 3\\n2 Apple : 12\\n1 Avocado : 5\\n3 Blackberries : 30\\n1 Cherries : 7\\ntotal : 81\\ndiscount price : 81\\n', ]\ncase inputs: [[['Blueberries', 'Blackberries', 'Cherries', 'Blackberries', 'Blackberries', 'Banana', 'Blackberries', 'Banana', 'Blackberries', 'Avocado'], {'Apple': 6, 'Avocado': 5, 'Banana': 3, 'Blackberries': 10, 'Blueberries': 12, 'Cherries': 7, 'Date Fruit': 14, 'Grapes': 15, 'Guava': 8, 'Jackfruit': 7, 'Kiwifruit': 9}], {}]\nResults: ['Salah', '1 Avocado : 5\\n2 Banana : 6\\n5 Blackberries : 50\\n1 Blueberries : 12\\n1 Cherries : 7\\ntotal : 80\\ndiscount price : 80\\n', , '1 Blueberries : 12\\n5 Blackberries : 50\\n1 Cherries : 7\\n2 Banana : 6\\n1 Avocado : 5\\ntotal : 80\\ndiscount price : 80\\n', ]\ncase inputs: [[['Avocado', 'Avocado', 'Blackberries', 'Blackberries', 'Banana', 'Apple', 'Blueberries', 'Cherries', 'Cherries', 'Cherries'], {'Apple': 6, 'Avocado': 5, 'Banana': 3, 'Blackberries': 10, 'Blueberries': 12, 'Cherries': 7, 'Date Fruit': 14, 'Grapes': 15, 'Guava': 8, 'Jackfruit': 7, 'Kiwifruit': 9}], {}]\nResults: ['Salah', '1 Apple : 6\\n2 Avocado : 10\\n1 Banana : 3\\n2 Blackberries : 20\\n1 Blueberries : 12\\n3 Cherries : 21\\ntotal : 72\\ndiscount price : 72\\n', , '2 Avocado : 10\\n2 Blackberries : 20\\n1 Banana : 3\\n1 Apple : 6\\n1 Blueberries : 12\\n3 Cherries : 21\\ntotal : 72\\ndiscount price : 72\\n', ]\n"
27 | ],
28 | "score": 80.0,
29 | "scores": [
30 | 1.0,
31 | 1.0,
32 | 1,
33 | 1.0,
34 | 0.8,
35 | 0.0
36 | ]
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/asets/persegilink.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/asets/persegilink.png
--------------------------------------------------------------------------------
/asets/pycalendar.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/asets/pycalendar.png
--------------------------------------------------------------------------------
/asets/pycalendar2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/asets/pycalendar2.png
--------------------------------------------------------------------------------
/asets/pydatetime.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/asets/pydatetime.png
--------------------------------------------------------------------------------
/asets/stack.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/asets/stack.png
--------------------------------------------------------------------------------
/class1.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/class1.JPG
--------------------------------------------------------------------------------
/class2.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/class2.JPG
--------------------------------------------------------------------------------
/inheritance.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sykrn/py-dts/35a5c80159fb53226a4e057b3129169fda749926/inheritance.JPG
--------------------------------------------------------------------------------
/project/DTS_project1_warmup_assignment_warmup.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "nbformat": 4,
3 | "nbformat_minor": 0,
4 | "metadata": {
5 | "colab": {
6 | "name": "DTS project assignment warmup.ipynb",
7 | "provenance": [],
8 | "collapsed_sections": [],
9 | "toc_visible": true,
10 | "include_colab_link": true
11 | },
12 | "kernelspec": {
13 | "name": "python3",
14 | "display_name": "Python 3"
15 | }
16 | },
17 | "cells": [
18 | {
19 | "cell_type": "markdown",
20 | "metadata": {
21 | "id": "view-in-github",
22 | "colab_type": "text"
23 | },
24 | "source": [
25 | ""
26 | ]
27 | },
28 | {
29 | "cell_type": "markdown",
30 | "metadata": {
31 | "id": "9swpmvv_IFlg",
32 | "colab_type": "text"
33 | },
34 | "source": [
35 | "# string"
36 | ]
37 | },
38 | {
39 | "cell_type": "code",
40 | "metadata": {
41 | "id": "_bnHG70h11tS",
42 | "colab_type": "code",
43 | "outputId": "f8c3a163-4de7-4a6d-ffa4-7f73c653bb7f",
44 | "colab": {
45 | "base_uri": "https://localhost:8080/",
46 | "height": 34
47 | }
48 | },
49 | "source": [
50 | "# materi 30 menit terakhir di video\n",
51 | "# string itu imutable\n",
52 | "s='abc'\n",
53 | "print(s[0])\n",
54 | "\n"
55 | ],
56 | "execution_count": 0,
57 | "outputs": [
58 | {
59 | "output_type": "stream",
60 | "text": [
61 | "a\n"
62 | ],
63 | "name": "stdout"
64 | }
65 | ]
66 | },
67 | {
68 | "cell_type": "markdown",
69 | "metadata": {
70 | "id": "MuQJs_7oIhIb",
71 | "colab_type": "text"
72 | },
73 | "source": [
74 | "# Collection\n",
75 | "1. List\n",
76 | "2. Tuple\n",
77 | "3. Dictionary\n",
78 | "\n"
79 | ]
80 | },
81 | {
82 | "cell_type": "code",
83 | "metadata": {
84 | "id": "8M_YJckJIFVO",
85 | "colab_type": "code",
86 | "outputId": "be94e262-6f0d-43d2-9599-195888d43264",
87 | "colab": {
88 | "base_uri": "https://localhost:8080/",
89 | "height": 105
90 | }
91 | },
92 | "source": [
93 | "ls = [7,1,2,3,4,5]\n",
94 | "print(sum(ls))\n",
95 | "\n",
96 | "ls = ['asd','a7,1,2,3,4,5']\n",
97 | "print('sebelum di sort:',ls)\n",
98 | "print(ls[1]"
37 | ]
38 | },
39 | {
40 | "cell_type": "markdown",
41 | "metadata": {
42 | "id": "CRS2GeLCQNxo",
43 | "colab_type": "text"
44 | },
45 | "source": [
46 | "# Pengenalan `Numpy` library\n",
47 | "
\n",
48 | "
\n",
49 | "
\n",
50 | "\n",
51 | "\n",
52 | "### Dr. Syukron Abu Ishaq Alfarozi\n",
53 | "Source: https://numpy.org/devdocs/user/absolute_beginners.html\n",
54 | "\n"
55 | ]
56 | },
57 | {
58 | "cell_type": "markdown",
59 | "metadata": {
60 | "id": "SEDMk76AQNxt",
61 | "colab_type": "text"
62 | },
63 | "source": [
64 | "## Apa itu numpy?\n",
65 | "Numpy merupakan suatu library open source di python untuk membuat/memanipulasi suatu multi-dimensional array. \n",
66 | "\n",
67 | "### Apa keuntungannya mengunakan numpy?\n",
68 | "Numpy mendukung operasi-operasi yang lebih cepat dan eficient dibandingkan dengan operasi python biasa pada list.\n",
69 | "> menggunakan openBLAS atau intel MKL untuk mempercepat pemrosesan array.\n",
70 | "\n",
71 | "### Kenapa diperlukan pemrosesan yang lebih eficient?\n",
72 | "* Python merupakan bahasa pemrograman berbasis interpreter. -> Lambat.\n",
73 | "* Data yang besar akan sangat terasa lambat kalau menggunakan python tipe data.\n",
74 | "* Numpy memfalitasi untuk menggunakan compiled library untuk pemrosesan array.\n"
75 | ]
76 | },
77 | {
78 | "cell_type": "markdown",
79 | "metadata": {
80 | "id": "7s0fm4UBQNxx",
81 | "colab_type": "text"
82 | },
83 | "source": [
84 | "## Instalasi\n",
85 | "1. `pip install numpy`\n",
86 | "2. `conda install numpy`\n"
87 | ]
88 | },
89 | {
90 | "cell_type": "markdown",
91 | "metadata": {
92 | "id": "8DZFA5IGQNx0",
93 | "colab_type": "text"
94 | },
95 | "source": [
96 | "## Numpy basic"
97 | ]
98 | },
99 | {
100 | "cell_type": "code",
101 | "metadata": {
102 | "id": "7WybozwAQNx3",
103 | "colab_type": "code",
104 | "colab": {}
105 | },
106 | "source": [
107 | "import numpy as np"
108 | ],
109 | "execution_count": null,
110 | "outputs": []
111 | },
112 | {
113 | "cell_type": "code",
114 | "metadata": {
115 | "id": "c9nBRSNiQNyL",
116 | "colab_type": "code",
117 | "colab": {}
118 | },
119 | "source": [
120 | "a = np.array([1, 2, 3, 4, 5, 6])\n",
121 | "b = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\n"
122 | ],
123 | "execution_count": null,
124 | "outputs": []
125 | },
126 | {
127 | "cell_type": "code",
128 | "metadata": {
129 | "id": "I2wRjYwWQNyb",
130 | "colab_type": "code",
131 | "colab": {},
132 | "outputId": "32b6737f-667b-4db7-d41e-3c9b49d503e0"
133 | },
134 | "source": [
135 | "ls = [1, 2, 3, 4, 5, 6]\n",
136 | "# print(ls**2) #error unsupported operand\n",
137 | "print(a**2)\n",
138 | "print(a*a - a)"
139 | ],
140 | "execution_count": null,
141 | "outputs": [
142 | {
143 | "output_type": "stream",
144 | "text": [
145 | "[ 1 4 9 16 25 36]\n",
146 | "[ 0 2 6 12 20 30]\n"
147 | ],
148 | "name": "stdout"
149 | }
150 | ]
151 | },
152 | {
153 | "cell_type": "code",
154 | "metadata": {
155 | "id": "Cm50sM3WQNyu",
156 | "colab_type": "code",
157 | "colab": {},
158 | "outputId": "3b06c141-3baf-4cec-a393-f5ef5083d061"
159 | },
160 | "source": [
161 | "a = list(range(1000))\n",
162 | "\n",
163 | "print('list', end=': ')\n",
164 | "%timeit [i**2 for i in a]\n",
165 | "\n",
166 | "print('numpy', end=': ')\n",
167 | "a = np.array(a)\n",
168 | "%timeit a**2"
169 | ],
170 | "execution_count": null,
171 | "outputs": [
172 | {
173 | "output_type": "stream",
174 | "text": [
175 | "list: 331 µs ± 13.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
176 | "numpy: 1.58 µs ± 11.4 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
177 | ],
178 | "name": "stdout"
179 | }
180 | ]
181 | },
182 | {
183 | "cell_type": "markdown",
184 | "metadata": {
185 | "id": "8Y9dot_HQNy_",
186 | "colab_type": "text"
187 | },
188 | "source": [
189 | "### Basic Array\n",
190 | ""
191 | ]
192 | },
193 | {
194 | "cell_type": "code",
195 | "metadata": {
196 | "id": "MCyrMQQXQNzC",
197 | "colab_type": "code",
198 | "colab": {}
199 | },
200 | "source": [
201 | "a = np.zeros(2)\n",
202 | "b = np.ones(2)\n",
203 | "c = np.empty(2)\n",
204 | "d = np.arange(4)"
205 | ],
206 | "execution_count": null,
207 | "outputs": []
208 | },
209 | {
210 | "cell_type": "code",
211 | "metadata": {
212 | "id": "DRJVBuPTQNzL",
213 | "colab_type": "code",
214 | "colab": {}
215 | },
216 | "source": [
217 | "a = np.arange(2, 9, 2) # first number, last number, and the step size\n",
218 | "b = np.linspace(0, 10, num=5) # first number, last number, and number of points"
219 | ],
220 | "execution_count": null,
221 | "outputs": []
222 | },
223 | {
224 | "cell_type": "code",
225 | "metadata": {
226 | "id": "M4-pvPzHQNzZ",
227 | "colab_type": "code",
228 | "colab": {}
229 | },
230 | "source": [
231 | "x = np.ones(2, dtype=np.int64) #add data type"
232 | ],
233 | "execution_count": null,
234 | "outputs": []
235 | },
236 | {
237 | "cell_type": "markdown",
238 | "metadata": {
239 | "id": "ESIXRE9WQNzh",
240 | "colab_type": "text"
241 | },
242 | "source": [
243 | "## Adding, removing, and sorting elements¶\n",
244 | "`np.sort()`, `np.concatenate()`\n",
245 | "\n",
246 | "\n"
247 | ]
248 | },
249 | {
250 | "cell_type": "code",
251 | "metadata": {
252 | "id": "_YqE4RImQNzj",
253 | "colab_type": "code",
254 | "colab": {}
255 | },
256 | "source": [
257 | "arr = np.array([2, 1, 5, 3, 7, 4, 6, 8])\n",
258 | "np.sort(arr)"
259 | ],
260 | "execution_count": null,
261 | "outputs": []
262 | },
263 | {
264 | "cell_type": "code",
265 | "metadata": {
266 | "id": "qMPUsIxsQNzq",
267 | "colab_type": "code",
268 | "colab": {}
269 | },
270 | "source": [
271 | "a = np.array([1, 2, 3, 4])\n",
272 | "b = np.array([5, 6, 7, 8])\n",
273 | "np.concatenate((a, b))"
274 | ],
275 | "execution_count": null,
276 | "outputs": []
277 | },
278 | {
279 | "cell_type": "code",
280 | "metadata": {
281 | "id": "_w9YIafCQNzx",
282 | "colab_type": "code",
283 | "colab": {}
284 | },
285 | "source": [
286 | "x = np.array([[1, 2], [3, 4]])\n",
287 | "y = np.array([[5, 6]])\n",
288 | "np.concatenate((x, y), axis=0)"
289 | ],
290 | "execution_count": null,
291 | "outputs": []
292 | },
293 | {
294 | "cell_type": "markdown",
295 | "metadata": {
296 | "id": "1JCBeZGMQNz7",
297 | "colab_type": "text"
298 | },
299 | "source": [
300 | "## Array properties\n",
301 | "`ndarray.ndim`, `ndarray.size`, `ndarray.shape`"
302 | ]
303 | },
304 | {
305 | "cell_type": "code",
306 | "metadata": {
307 | "id": "VaUxI00VQNz9",
308 | "colab_type": "code",
309 | "colab": {},
310 | "outputId": "7e2ec554-ed64-43d2-bc29-3d50ba6aa887"
311 | },
312 | "source": [
313 | "arr = np.array([[[0, 1, 2, 3],\n",
314 | " [4, 5, 6, 7]],\n",
315 | "\n",
316 | " [[0, 1, 2, 3],\n",
317 | " [4, 5, 6, 7]],\n",
318 | "\n",
319 | " [[0 ,1 ,2, 3],\n",
320 | " [4, 5, 6, 7]]])\n",
321 | "print(arr.ndim,arr.size,arr.shape,sep='__')"
322 | ],
323 | "execution_count": null,
324 | "outputs": [
325 | {
326 | "output_type": "stream",
327 | "text": [
328 | "3__24__(3, 2, 4)\n"
329 | ],
330 | "name": "stdout"
331 | }
332 | ]
333 | },
334 | {
335 | "cell_type": "code",
336 | "metadata": {
337 | "id": "JScm3LcRQN0H",
338 | "colab_type": "code",
339 | "colab": {}
340 | },
341 | "source": [
342 | "# change the shape using reshape\n",
343 | "a = np.arange(6)\n",
344 | "print(a)\n",
345 | "\n",
346 | "b = a.reshape(3, 2)\n",
347 | "print(b)\n",
348 | "\n",
349 | "c=np.reshape(a, newshape=(1, 6), order='C')\n",
350 | "print(callable)\n",
351 | "\n"
352 | ],
353 | "execution_count": null,
354 | "outputs": []
355 | },
356 | {
357 | "cell_type": "code",
358 | "metadata": {
359 | "id": "e3gtyMzPQN0P",
360 | "colab_type": "code",
361 | "colab": {}
362 | },
363 | "source": [
364 | "# add new axis\n",
365 | "a = np.array([1, 2, 3, 4, 5, 6])\n",
366 | "print(a.shape)\n",
367 | "a2 = a[np.newaxis, :]\n",
368 | "print(a2)\n",
369 | "b = np.expand_dims(a, axis=1) \n",
370 | "b.shape"
371 | ],
372 | "execution_count": null,
373 | "outputs": []
374 | },
375 | {
376 | "cell_type": "markdown",
377 | "metadata": {
378 | "id": "oWMX8NypQN0Z",
379 | "colab_type": "text"
380 | },
381 | "source": [
382 | "## Indexing and Slicing"
383 | ]
384 | },
385 | {
386 | "cell_type": "code",
387 | "metadata": {
388 | "id": "3o-FePL5QN0b",
389 | "colab_type": "code",
390 | "colab": {},
391 | "outputId": "fec6d4df-9485-4420-ed6b-e112470c82b8"
392 | },
393 | "source": [
394 | "data = np.array([1, 2, 3])\n",
395 | "print(data[1])\n",
396 | "print(data[0:2])\n",
397 | "print(data[1:])\n",
398 | "print(data[-2:])"
399 | ],
400 | "execution_count": null,
401 | "outputs": [
402 | {
403 | "output_type": "stream",
404 | "text": [
405 | "2\n",
406 | "[1 2]\n",
407 | "[2 3]\n",
408 | "[2 3]\n"
409 | ],
410 | "name": "stdout"
411 | }
412 | ]
413 | },
414 | {
415 | "cell_type": "markdown",
416 | "metadata": {
417 | "id": "PPdHYG9FQN0j",
418 | "colab_type": "text"
419 | },
420 | "source": [
421 | ""
422 | ]
423 | },
424 | {
425 | "cell_type": "code",
426 | "metadata": {
427 | "id": "SNajadWsQN0k",
428 | "colab_type": "code",
429 | "colab": {},
430 | "outputId": "1b80a774-a71f-420c-e546-fb665b0592b3"
431 | },
432 | "source": [
433 | "#Boolean index\n",
434 | "print(data[[False,True,False]])"
435 | ],
436 | "execution_count": null,
437 | "outputs": [
438 | {
439 | "output_type": "stream",
440 | "text": [
441 | "[2]\n"
442 | ],
443 | "name": "stdout"
444 | }
445 | ]
446 | },
447 | {
448 | "cell_type": "code",
449 | "metadata": {
450 | "id": "yg4CUh6gQN0u",
451 | "colab_type": "code",
452 | "colab": {},
453 | "outputId": "8d6a981e-62d0-4bcd-f646-845b3afb058f"
454 | },
455 | "source": [
456 | "a = np.array([[1 , 2, 3, 4], [1, 6, 7, 8], [9, 10, 11, 2]])\n",
457 | "print(a<5)\n",
458 | "print(a[a<5])"
459 | ],
460 | "execution_count": null,
461 | "outputs": [
462 | {
463 | "output_type": "stream",
464 | "text": [
465 | "[[ True True True True]\n",
466 | " [ True False False False]\n",
467 | " [False False False True]]\n",
468 | "[1 2 3 4 1 2]\n"
469 | ],
470 | "name": "stdout"
471 | }
472 | ]
473 | },
474 | {
475 | "cell_type": "code",
476 | "metadata": {
477 | "id": "IW_gsw7XQN03",
478 | "colab_type": "code",
479 | "colab": {},
480 | "outputId": "2c3210b8-7504-4c14-cb5e-87c7448a96ca"
481 | },
482 | "source": [
483 | "# logical operators\n",
484 | "c = a[(a > 2) & (a < 11)]\n",
485 | "print(c)"
486 | ],
487 | "execution_count": null,
488 | "outputs": [
489 | {
490 | "output_type": "stream",
491 | "text": [
492 | "[ 3 4 6 7 8 9 10]\n"
493 | ],
494 | "name": "stdout"
495 | }
496 | ]
497 | },
498 | {
499 | "cell_type": "markdown",
500 | "metadata": {
501 | "id": "6Q8e--u-QN0_",
502 | "colab_type": "text"
503 | },
504 | "source": [
505 | "## How to create an array from existing data\n",
506 | "This section covers slicing and indexing, `np.vstack()`, `np.hstack()`, `np.hsplit()`, `.view()`, `copy()`\n",
507 | "\n"
508 | ]
509 | },
510 | {
511 | "cell_type": "code",
512 | "metadata": {
513 | "id": "9rBvcbmXQN1A",
514 | "colab_type": "code",
515 | "colab": {}
516 | },
517 | "source": [
518 | "a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])\n",
519 | "arr1 = a[3:8]\n",
520 | "arr1"
521 | ],
522 | "execution_count": null,
523 | "outputs": []
524 | },
525 | {
526 | "cell_type": "code",
527 | "metadata": {
528 | "id": "OCh0tNOmQN1H",
529 | "colab_type": "code",
530 | "colab": {}
531 | },
532 | "source": [
533 | "a1 = np.array([[1, 1],\n",
534 | " [2, 2]])\n",
535 | "\n",
536 | "a2 = np.array([[3, 3],\n",
537 | " [4, 4]])\n",
538 | "np.vstack((a1, a2))\n"
539 | ],
540 | "execution_count": null,
541 | "outputs": []
542 | },
543 | {
544 | "cell_type": "code",
545 | "metadata": {
546 | "id": "c51TSrk6QN1N",
547 | "colab_type": "code",
548 | "colab": {}
549 | },
550 | "source": [
551 | "np.hstack((a1, a2))\n"
552 | ],
553 | "execution_count": null,
554 | "outputs": []
555 | },
556 | {
557 | "cell_type": "code",
558 | "metadata": {
559 | "id": "lUp_LemgQN1U",
560 | "colab_type": "code",
561 | "colab": {}
562 | },
563 | "source": [
564 | "x = np.arange(1, 25).reshape(2, 12)\n",
565 | "print(x)\n",
566 | "np.hsplit(x, 3)\n"
567 | ],
568 | "execution_count": null,
569 | "outputs": []
570 | },
571 | {
572 | "cell_type": "code",
573 | "metadata": {
574 | "id": "J5fry53CQN1a",
575 | "colab_type": "code",
576 | "colab": {}
577 | },
578 | "source": [
579 | "np.hsplit(x, (3, 4))"
580 | ],
581 | "execution_count": null,
582 | "outputs": []
583 | },
584 | {
585 | "cell_type": "code",
586 | "metadata": {
587 | "id": "zxm6eKBoQN1i",
588 | "colab_type": "code",
589 | "colab": {}
590 | },
591 | "source": [
592 | "a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\n",
593 | "c = a.view()\n",
594 | "c is a"
595 | ],
596 | "execution_count": null,
597 | "outputs": []
598 | },
599 | {
600 | "cell_type": "code",
601 | "metadata": {
602 | "id": "zOMK0YqSQN1q",
603 | "colab_type": "code",
604 | "colab": {}
605 | },
606 | "source": [
607 | "# Slicing an array returns a view of it\n",
608 | "b1 = a[0, :]\n",
609 | "print(b1)\n",
610 | "b1[0] = 99\n",
611 | "print(b1)"
612 | ],
613 | "execution_count": null,
614 | "outputs": []
615 | },
616 | {
617 | "cell_type": "code",
618 | "metadata": {
619 | "id": "d_035cqVQN1y",
620 | "colab_type": "code",
621 | "colab": {}
622 | },
623 | "source": [
624 | "print(a)"
625 | ],
626 | "execution_count": null,
627 | "outputs": []
628 | },
629 | {
630 | "cell_type": "markdown",
631 | "metadata": {
632 | "id": "QG7hSjIAQN14",
633 | "colab_type": "text"
634 | },
635 | "source": [
636 | "## Basic array operations\n",
637 | "addition, subtraction, multiplication, division, sum, min, max and more"
638 | ]
639 | },
640 | {
641 | "cell_type": "code",
642 | "metadata": {
643 | "id": "kWLBzyMtQN15",
644 | "colab_type": "code",
645 | "colab": {},
646 | "outputId": "f276e587-4bc3-43b8-cbf2-53f5a8110e6b"
647 | },
648 | "source": [
649 | "data = np.array([1, 2])\n",
650 | "ones = np.ones(2, dtype=int)\n",
651 | "\n",
652 | "#elementwise operations\n",
653 | "print(data + ones)\n",
654 | "print(data - ones)\n",
655 | "print(data * ones)\n",
656 | "print(data / ones)\n",
657 | "print(data % (ones*2))"
658 | ],
659 | "execution_count": null,
660 | "outputs": [
661 | {
662 | "output_type": "stream",
663 | "text": [
664 | "[2 3]\n",
665 | "[0 1]\n",
666 | "[1 2]\n",
667 | "[1. 2.]\n",
668 | "[1 0]\n"
669 | ],
670 | "name": "stdout"
671 | }
672 | ]
673 | },
674 | {
675 | "cell_type": "markdown",
676 | "metadata": {
677 | "id": "rv1VYdg1QN1_",
678 | "colab_type": "text"
679 | },
680 | "source": [
681 | "## More ...\n"
682 | ]
683 | },
684 | {
685 | "cell_type": "code",
686 | "metadata": {
687 | "id": "zXAuBWxuQN2A",
688 | "colab_type": "code",
689 | "colab": {}
690 | },
691 | "source": [
692 | ""
693 | ],
694 | "execution_count": null,
695 | "outputs": []
696 | }
697 | ]
698 | }
--------------------------------------------------------------------------------
/project/QnA_gado2_30062020.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "nbformat": 4,
3 | "nbformat_minor": 0,
4 | "metadata": {
5 | "colab": {
6 | "name": "QnA gado2.ipynb",
7 | "provenance": [],
8 | "authorship_tag": "ABX9TyMgnf+jPOyxReYFJYuUPJyC",
9 | "include_colab_link": true
10 | },
11 | "kernelspec": {
12 | "name": "python3",
13 | "display_name": "Python 3"
14 | }
15 | },
16 | "cells": [
17 | {
18 | "cell_type": "markdown",
19 | "metadata": {
20 | "id": "view-in-github",
21 | "colab_type": "text"
22 | },
23 | "source": [
24 | ""
25 | ]
26 | },
27 | {
28 | "cell_type": "code",
29 | "metadata": {
30 | "id": "IKyBr9hiUXBW",
31 | "colab_type": "code",
32 | "colab": {
33 | "base_uri": "https://localhost:8080/",
34 | "height": 85
35 | },
36 | "outputId": "bb7f5cba-f347-4d0d-b33a-45e9ffa418f2"
37 | },
38 | "source": [
39 | "import pandas as pd\n",
40 | "\n",
41 | "df = pd.DataFrame({'Animal': ['Falcon', 'Falcon',\n",
42 | " 'Parrot', 'Parrot'],\n",
43 | " 'Max Speed': ['380.', '370.', '24.', '26.'],\n",
44 | " 'items':[1,2,3,4]})\n",
45 | "df.dtypes"
46 | ],
47 | "execution_count": null,
48 | "outputs": [
49 | {
50 | "output_type": "execute_result",
51 | "data": {
52 | "text/plain": [
53 | "Animal object\n",
54 | "Max Speed object\n",
55 | "items int64\n",
56 | "dtype: object"
57 | ]
58 | },
59 | "metadata": {
60 | "tags": []
61 | },
62 | "execution_count": 10
63 | }
64 | ]
65 | },
66 | {
67 | "cell_type": "code",
68 | "metadata": {
69 | "id": "yNEhm-9jU2Df",
70 | "colab_type": "code",
71 | "colab": {
72 | "base_uri": "https://localhost:8080/",
73 | "height": 204
74 | },
75 | "outputId": "1f151171-f691-4bd1-98c4-6bc390598658"
76 | },
77 | "source": [
78 | "df.groupby(['Max Speed']).mean()"
79 | ],
80 | "execution_count": null,
81 | "outputs": [
82 | {
83 | "output_type": "execute_result",
84 | "data": {
85 | "text/html": [
86 | "\n",
87 | "\n",
100 | "
\n",
101 | " \n",
102 | " \n",
103 | " | \n",
104 | " items | \n",
105 | "
\n",
106 | " \n",
107 | " | Max Speed | \n",
108 | " | \n",
109 | "
\n",
110 | " \n",
111 | " \n",
112 | " \n",
113 | " | 24. | \n",
114 | " 3 | \n",
115 | "
\n",
116 | " \n",
117 | " | 26. | \n",
118 | " 4 | \n",
119 | "
\n",
120 | " \n",
121 | " | 370. | \n",
122 | " 2 | \n",
123 | "
\n",
124 | " \n",
125 | " | 380. | \n",
126 | " 1 | \n",
127 | "
\n",
128 | " \n",
129 | "
\n",
130 | "