5 |
4 |
5 |
31 |
32 | 
37 | 38 | Tarun Kumar 39 | 40 | 41 | Lead Instructor 42 | 43 | |
44 |
45 |
46 | 
51 | 52 | Bahawal Baloch 53 | 54 | 55 | Co-Lead Instructor 56 | 57 | |
58 |
39 |
40 | Remember the path being mentioned here.
41 |
42 | The default install path is in the AppData/ directory of the current Windows user.
43 |
44 | Keep "Add Python 3.8 to PATH" unselected
45 |
46 | 3. Voila, you have Python installed on your Windows machine.
47 |
48 | ### Path Configuration (Windows only)
49 |
50 | However you cannot start programming with Python yet, atleast not on a system-wide level. To do so, you must configure your PATH so that Windows knows what Python is.
51 |
52 | To do so:
53 |
54 | 1. Press windows key
55 |
56 | 2. Search for "environment variables" and open "Edit the system environment variables"
57 |
58 | 
59 |
60 | 3. Click the environment variables button:
61 |
62 | 
63 |
64 | 4. In the bottom dialog(system variables), click on the variable with name PATH and click edit
65 |
66 | 
67 |
68 | 5. Click on new button and paste in the following
69 |
70 | 1) Path where we installed Python in step 2, for me it was:
71 |
72 | ```bash
73 | C:\Users\Tarun\AppData\Local\Programs\Python\Python39
74 | ```
75 |
76 | 
77 |
78 | 2. Same path as above with the addition of **\Scripts** at the end.
79 |
80 | ```bash
81 | C:\Users\Tarun\AppData\Local\Programs\Python\Python39\Scripts
82 | ```
83 |
84 | 
85 |
86 | 6. Voila, you can now run Python in your system. To verify that you've done everything correctly just open a command prompt window or PowerShell window and just type in:
87 |
88 | ```bash
89 | python --version
90 | ```
91 |
92 | You shall get a response similar to this,
93 |
94 | 
95 |
96 | if you don't, make sure you've followed the steps correctly, alternatively you can watch the video for today's lecture.
97 |
98 | ### What is PIP?
99 |
100 | In a modern language, libraries and frameworks allow you to use existing codebase to fast-track your development. You don't necessarily need to reinvent the wheel for most cases if the existing solution has had years of development and is probably faster than whatever you could write.
101 |
102 | So in such cases, you may use existing code that is written and deployed in modules called **_packages_** that you can conveniently import into your own codebase and start using the **_functions, classes_** and **_objects_** that it provides.
103 |
104 | Now to apply a simple interface for the installation and configuration of such packages, Python uses a package manager called **_pip_** which comes pre-installed with a Python installation.
105 |
106 | To verify **_pip_** is installed:
107 |
108 | ```bash
109 | pip --version
110 | ```
111 |
112 | Output:
113 |
114 | 
115 |
116 | To install any package with pip, you just do:
117 |
118 | ```bash
119 | pip install package-name
120 | ```
121 |
122 | To find existing packages that people have created for Python, you can check out **[Py**thon **P**ackage **I**ndex](https://pypi.org/)
123 |
124 | ### How does Python code run?
125 |
126 | In the programming world, **Python** belongs to a family of interpreted (dynamically typed) languages like _JavaScript_, _PHP, Ruby, Perl_ etc.
127 |
128 | The advantage of being dynamically typed is that Python does not require the programmer to keep track of variable datatypes and throughout the life of a program, the variable may change not only it's value but also it's datatype. This makes writing code a breeze.
129 |
130 | Now the term used to identify programs written in dynamically typed languages (like Python) is "script" and we'll be using the term from here on out.
131 |
132 | Now to run Python code, we have three options.
133 |
134 | ### Running Python: **Interactive shell (terminal)**
135 |
136 | Simply open a command prompt or terminal window and type in `python` and you'll enter an interactive shell:
137 |
138 | 
139 |
140 | This can act as a workbench for you to test your code logic before writing it into a script. For example slicing a string, playing with custom formulas etcetera.
141 |
142 | ## Running Python: **Interactive Python notebooks (Jupyter Notebook/Google Colab)**
143 |
144 | **Jupyter Notebooks** are perhaps one of the most comprehensive way to write manuals, documentation, labs, presentations and visualizations using only Python.
145 |
146 | To get started with using **Jupyter Notebook**, you need to install the **Jupyter** module using **pip**
147 |
148 | Just open CMD/Terminal and write:
149 |
150 | ```bash
151 | pip install jupyter
152 | ```
153 |
154 | Now this may take a little while to complete, let it since it's downloading some large dependencies.
155 |
156 | Now Jupyter Notebook run on an server environment because it runs a containerized Python kernel which you don't need to confuse yourself with, so just remember to run a local instance of Jupyter Notebook you need to type the following in terminal after installing (using command shown above):
157 |
158 | ```bash
159 | jupyter notebook
160 | ```
161 |
162 | This'll launch a [localhost](http://localhost) server and you can view it at [http://localhost:8888/tree](http://localhost:8888/tree) on your browser (running the above command opens it directly)
163 |
164 | Now just create a new file:
165 |
166 | 
167 |
168 | You can start writing code in individual cells and execute by pressing `shift + enter`
169 |
170 | 
171 |
172 | The new file you just created will have the extension `.ipynb` which signifies that the file is an Interactive Python Notebook.
173 |
174 | Besides you can use Jupyter Notebooks to write Markdown code as well to provide proper documentation to your presentation. The possibilities are limitless on sharing code that not only you can understand, but you can provide proper documentation so that even a layman may understand what you're trying to do in a code section.
175 |
176 | Take a look at this notebook to see the possibilities:
177 |
178 | [Exploratory Computing with Python](https://nbviewer.jupyter.org/github/mbakker7/exploratory_computing_with_python/blob/master/notebook1_basics_plotting/py_exploratory_comp_1_sol.ipynb)
179 |
180 | If you face the following issue after running `jupyter notebook` on your Windows system:
181 |
182 | 
183 |
184 | You can fix it by installing the Visual C++ redistributable files from [here](https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads)
185 |
186 | ### Running Python: **Scripts**
187 |
188 | Now this is how you'll be spending most of your time on Python. Building scripts that do stuff without any flashy interactive outputs or markdown to explain code.
189 |
190 | To write Python scripts, you can:
191 |
192 | - use any code editor (Visual Studio Code, Sublime Text, Notepad++ or even Vim if you're badass enough)
193 | - use IDEs (PyCharm, IDLE, Spyder)
194 |
195 | I personally love to work on projects that span through multiple languages and frameworks, so Visual Studio Code works for me due to having the lightness of a code editor and great extension support.
196 |
197 | You can write code on Word or Google Docs for all Python cares (make sure you convert the code to plaintext first though because it may raise syntax errors otherwise :p ).
198 |
--------------------------------------------------------------------------------
/python_bootcamp_2020/week_1/day_2/.ipynb_checkpoints/bootcamp_day_2 -checkpoint.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## Let's Start\n",
8 | "### Variables\n",
9 | "- dynamically type"
10 | ]
11 | },
12 | {
13 | "cell_type": "code",
14 | "execution_count": 14,
15 | "metadata": {},
16 | "outputs": [],
17 | "source": [
18 | "# int a = 5 C/C++ or java\n",
19 | "a = '5.0'"
20 | ]
21 | },
22 | {
23 | "cell_type": "code",
24 | "execution_count": 15,
25 | "metadata": {},
26 | "outputs": [
27 | {
28 | "data": {
29 | "text/plain": [
30 | "str"
31 | ]
32 | },
33 | "execution_count": 15,
34 | "metadata": {},
35 | "output_type": "execute_result"
36 | }
37 | ],
38 | "source": [
39 | "type(a)"
40 | ]
41 | },
42 | {
43 | "cell_type": "markdown",
44 | "metadata": {},
45 | "source": [
46 | "### Primitive data type\n",
47 | " 1. int\n",
48 | " 2. float\n",
49 | " 3. string(str)\n",
50 | " 4. bool\n"
51 | ]
52 | },
53 | {
54 | "cell_type": "code",
55 | "execution_count": 1,
56 | "metadata": {},
57 | "outputs": [],
58 | "source": [
59 | "a = 5.0\n",
60 | "print(type(a))\n",
61 | "a = 5 \n",
62 | "print(type(a))"
63 | ]
64 | },
65 | {
66 | "cell_type": "code",
67 | "execution_count": 24,
68 | "metadata": {},
69 | "outputs": [
70 | {
71 | "data": {
72 | "text/plain": [
73 | "False"
74 | ]
75 | },
76 | "execution_count": 24,
77 | "metadata": {},
78 | "output_type": "execute_result"
79 | }
80 | ],
81 | "source": [
82 | "bool('')"
83 | ]
84 | },
85 | {
86 | "cell_type": "markdown",
87 | "metadata": {},
88 | "source": [
89 | "### Global vs local scope\n",
90 | "\n",
91 | "In most programming languages, variables, classes and objects (and sometimes functions) have scope where they may be referenced and mutated, Python also has a global and local scope.\n",
92 | "\n",
93 | "- Global variables as their name suggests may be accessed through out the program, however cannot be referenced from a function's local scope.\n",
94 | "- Local variables exist within a function's scope and cannot be accessed outside that function."
95 | ]
96 | },
97 | {
98 | "cell_type": "code",
99 | "execution_count": 35,
100 | "metadata": {},
101 | "outputs": [
102 | {
103 | "name": "stdout",
104 | "output_type": "stream",
105 | "text": [
106 | "25\n"
107 | ]
108 | }
109 | ],
110 | "source": [
111 | "x = 5 \n",
112 | "def func():\n",
113 | " global x\n",
114 | " x = x * 5\n",
115 | " print(x)\n",
116 | "func()"
117 | ]
118 | },
119 | {
120 | "cell_type": "code",
121 | "execution_count": 41,
122 | "metadata": {},
123 | "outputs": [
124 | {
125 | "name": "stdout",
126 | "output_type": "stream",
127 | "text": [
128 | "x in local local\n",
129 | "x in global local\n"
130 | ]
131 | }
132 | ],
133 | "source": [
134 | "x = 'global'\n",
135 | "def my_func():\n",
136 | " global x\n",
137 | " x=\"local\"\n",
138 | " print('x in local',x)\n",
139 | "my_func()\n",
140 | "print('x in global',x)"
141 | ]
142 | },
143 | {
144 | "cell_type": "markdown",
145 | "metadata": {},
146 | "source": [
147 | "### Printing in Python"
148 | ]
149 | },
150 | {
151 | "cell_type": "code",
152 | "execution_count": 57,
153 | "metadata": {},
154 | "outputs": [
155 | {
156 | "name": "stdout",
157 | "output_type": "stream",
158 | "text": [
159 | "hello world local\n"
160 | ]
161 | }
162 | ],
163 | "source": [
164 | "print(f'hello world {x}')"
165 | ]
166 | },
167 | {
168 | "cell_type": "code",
169 | "execution_count": 2,
170 | "metadata": {},
171 | "outputs": [
172 | {
173 | "name": "stdout",
174 | "output_type": "stream",
175 | "text": [
176 | "python bootcamp\n"
177 | ]
178 | }
179 | ],
180 | "source": [
181 | "print ('python '+ 'bootcamp')"
182 | ]
183 | },
184 | {
185 | "cell_type": "markdown",
186 | "metadata": {},
187 | "source": [
188 | "### Input in python "
189 | ]
190 | },
191 | {
192 | "cell_type": "code",
193 | "execution_count": 77,
194 | "metadata": {},
195 | "outputs": [
196 | {
197 | "name": "stdout",
198 | "output_type": "stream",
199 | "text": [
200 | "Enter number:5\n"
201 | ]
202 | }
203 | ],
204 | "source": [
205 | "x = float(input('Enter number:'))"
206 | ]
207 | },
208 | {
209 | "cell_type": "markdown",
210 | "metadata": {},
211 | "source": [
212 | "### Casting types"
213 | ]
214 | },
215 | {
216 | "cell_type": "code",
217 | "execution_count": 3,
218 | "metadata": {},
219 | "outputs": [
220 | {
221 | "name": "stdout",
222 | "output_type": "stream",
223 | "text": [
224 | "5\n"
225 | ]
226 | }
227 | ],
228 | "source": [
229 | "a = 5.0 \n",
230 | "a = int(a)\n",
231 | "print(a)"
232 | ]
233 | },
234 | {
235 | "cell_type": "code",
236 | "execution_count": 5,
237 | "metadata": {},
238 | "outputs": [
239 | {
240 | "name": "stdout",
241 | "output_type": "stream",
242 | "text": [
243 | "582\n",
244 | "582.0\n"
245 | ]
246 | }
247 | ],
248 | "source": [
249 | "b = '582'\n",
250 | "print(int(b))\n",
251 | "print(float(b))"
252 | ]
253 | },
254 | {
255 | "cell_type": "markdown",
256 | "metadata": {},
257 | "source": [
258 | "### Swapping variables "
259 | ]
260 | },
261 | {
262 | "cell_type": "code",
263 | "execution_count": 86,
264 | "metadata": {},
265 | "outputs": [],
266 | "source": [
267 | "a = 5\n",
268 | "b = 4"
269 | ]
270 | },
271 | {
272 | "cell_type": "code",
273 | "execution_count": 96,
274 | "metadata": {},
275 | "outputs": [],
276 | "source": [
277 | "a , b = b , a "
278 | ]
279 | },
280 | {
281 | "cell_type": "code",
282 | "execution_count": 97,
283 | "metadata": {},
284 | "outputs": [
285 | {
286 | "name": "stdout",
287 | "output_type": "stream",
288 | "text": [
289 | "8 9\n"
290 | ]
291 | }
292 | ],
293 | "source": [
294 | "print(a,b)"
295 | ]
296 | },
297 | {
298 | "cell_type": "markdown",
299 | "metadata": {},
300 | "source": [
301 | "## Control Structure\n",
302 | "### if else\n"
303 | ]
304 | },
305 | {
306 | "cell_type": "code",
307 | "execution_count": 6,
308 | "metadata": {},
309 | "outputs": [
310 | {
311 | "name": "stdout",
312 | "output_type": "stream",
313 | "text": [
314 | "enter a:5\n",
315 | "enter b:8\n",
316 | "a is greater than b\n"
317 | ]
318 | }
319 | ],
320 | "source": [
321 | "a = input('enter a:')\n",
322 | "b = input('enter b:')\n",
323 | "if a > b :\n",
324 | " print('a is greater than b')\n",
325 | "elif b > a :\n",
326 | " print('b is greater than a')\n",
327 | "else:\n",
328 | " print('both are equal')"
329 | ]
330 | },
331 | {
332 | "cell_type": "markdown",
333 | "metadata": {},
334 | "source": [
335 | "## Loops\n",
336 | "- for \n",
337 | "- while \n",
338 | "### loop keywords \n",
339 | "- break \n",
340 | "- continue \n",
341 | "### range function\n",
342 | "- first let's look at range function! \n"
343 | ]
344 | },
345 | {
346 | "cell_type": "code",
347 | "execution_count": 8,
348 | "metadata": {},
349 | "outputs": [
350 | {
351 | "name": "stdout",
352 | "output_type": "stream",
353 | "text": [
354 | "0-1-2-3-4-5-6-7-8-9-10-11-12-13-14-15-16-17-18-19-20-21-22-23-24-25-26-27-28-29-30-31-32-33-34-35-36-37-38-39-40-41-42-43-44-45-46-47-48-49-50-51-52-53-54-55-56-57-58-59-60-61-62-63-64-65-66-67-68-69-70-71-72-73-74-75-76-77-78-79-80-81-82-83-84-85-86-87-88-89-90-91-92-93-94-95-96-97-98-99-"
355 | ]
356 | }
357 | ],
358 | "source": [
359 | "for i in range(100):\n",
360 | " print(i,end='-')"
361 | ]
362 | },
363 | {
364 | "cell_type": "code",
365 | "execution_count": 126,
366 | "metadata": {},
367 | "outputs": [
368 | {
369 | "name": "stdout",
370 | "output_type": "stream",
371 | "text": [
372 | "1 5 8 6 "
373 | ]
374 | }
375 | ],
376 | "source": [
377 | "for i in [1,5,8,6]:\n",
378 | " print(i,end=' ')"
379 | ]
380 | },
381 | {
382 | "cell_type": "code",
383 | "execution_count": 135,
384 | "metadata": {},
385 | "outputs": [
386 | {
387 | "name": "stdout",
388 | "output_type": "stream",
389 | "text": [
390 | "p y t "
391 | ]
392 | }
393 | ],
394 | "source": [
395 | "for i in 'python':\n",
396 | " if i == 'h':\n",
397 | " break\n",
398 | " print(i,end=' ')\n",
399 | " "
400 | ]
401 | },
402 | {
403 | "cell_type": "code",
404 | "execution_count": 9,
405 | "metadata": {},
406 | "outputs": [
407 | {
408 | "name": "stdout",
409 | "output_type": "stream",
410 | "text": [
411 | "\n",
412 | "* \n",
413 | "* * \n",
414 | "* * * \n",
415 | "* * * * \n",
416 | "* * * * * \n"
417 | ]
418 | }
419 | ],
420 | "source": [
421 | "rows=6\n",
422 | "for i in range(rows):\n",
423 | " for j in range(i):\n",
424 | " print('*',end=\" \")\n",
425 | " print(\"\")"
426 | ]
427 | },
428 | {
429 | "cell_type": "code",
430 | "execution_count": 143,
431 | "metadata": {},
432 | "outputs": [
433 | {
434 | "name": "stdout",
435 | "output_type": "stream",
436 | "text": [
437 | "0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 "
438 | ]
439 | }
440 | ],
441 | "source": [
442 | "for i in range(50):\n",
443 | " if i==25:\n",
444 | " break\n",
445 | " print(i,end=' ')"
446 | ]
447 | },
448 | {
449 | "cell_type": "code",
450 | "execution_count": 10,
451 | "metadata": {},
452 | "outputs": [
453 | {
454 | "name": "stdout",
455 | "output_type": "stream",
456 | "text": [
457 | "enter string:585\n",
458 | "it's a palindrome\n"
459 | ]
460 | }
461 | ],
462 | "source": [
463 | "pf = input(\"enter string:\")\n",
464 | "fp = ''\n",
465 | "for i in range(len(pf)-1,-1,-1):\n",
466 | " fp+=pf[i]\n",
467 | "if(pf==fp):\n",
468 | " print(\"it's a palindrome\")\n",
469 | "else:\n",
470 | " print(\"it's a not palindrome\")"
471 | ]
472 | },
473 | {
474 | "cell_type": "code",
475 | "execution_count": 157,
476 | "metadata": {},
477 | "outputs": [
478 | {
479 | "name": "stdout",
480 | "output_type": "stream",
481 | "text": [
482 | "it'\n"
483 | ]
484 | }
485 | ],
486 | "source": [
487 | "print('it\\'')"
488 | ]
489 | },
490 | {
491 | "cell_type": "code",
492 | "execution_count": 11,
493 | "metadata": {},
494 | "outputs": [
495 | {
496 | "data": {
497 | "text/plain": [
498 | "48"
499 | ]
500 | },
501 | "execution_count": 11,
502 | "metadata": {},
503 | "output_type": "execute_result"
504 | }
505 | ],
506 | "source": [
507 | "len('len will return no. of characters in this string')"
508 | ]
509 | },
510 | {
511 | "cell_type": "code",
512 | "execution_count": null,
513 | "metadata": {},
514 | "outputs": [],
515 | "source": []
516 | }
517 | ],
518 | "metadata": {
519 | "kernelspec": {
520 | "display_name": "Python 3",
521 | "language": "python",
522 | "name": "python3"
523 | },
524 | "language_info": {
525 | "codemirror_mode": {
526 | "name": "ipython",
527 | "version": 3
528 | },
529 | "file_extension": ".py",
530 | "mimetype": "text/x-python",
531 | "name": "python",
532 | "nbconvert_exporter": "python",
533 | "pygments_lexer": "ipython3",
534 | "version": "3.7.6"
535 | }
536 | },
537 | "nbformat": 4,
538 | "nbformat_minor": 4
539 | }
540 |
--------------------------------------------------------------------------------
/python_bootcamp_2020/week_1/day_2/Lecture Notes ab4cded2c8ea400186b447dadfc415bf/Untitled 1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sinnytk/DSC-DSU/b8f4653c0617e968b2a73a8165986ddf87317e3e/python_bootcamp_2020/week_1/day_2/Lecture Notes ab4cded2c8ea400186b447dadfc415bf/Untitled 1.png
--------------------------------------------------------------------------------
/python_bootcamp_2020/week_1/day_2/Lecture Notes ab4cded2c8ea400186b447dadfc415bf/Untitled.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sinnytk/DSC-DSU/b8f4653c0617e968b2a73a8165986ddf87317e3e/python_bootcamp_2020/week_1/day_2/Lecture Notes ab4cded2c8ea400186b447dadfc415bf/Untitled.png
--------------------------------------------------------------------------------
/python_bootcamp_2020/week_1/day_2/README.md:
--------------------------------------------------------------------------------
1 | # Lecture Notes
2 |
3 |
Designer, UI
47 |London, UK
48 |April 1, 1988
49 |
85 | {{value[2]}}
86 | {{value[1]}}
89 | 90 | 91 |
29 |