![](\"media/jupyter_8.PNG\"/)
\n",
28 | "\n",
29 | "You can see a code cell just below this cell as well:"
30 | ]
31 | },
32 | {
33 | "cell_type": "code",
34 | "execution_count": null,
35 | "metadata": {},
36 | "outputs": [],
37 | "source": []
38 | },
39 | {
40 | "cell_type": "code",
41 | "execution_count": 1,
42 | "metadata": {},
43 | "outputs": [],
44 | "source": [
45 | "# Tip: Just copy and paste the print statement.\n",
46 | "# BTW, this is a code cell, but the lines starting with the hash symbol # are comments - they are ignored.\n",
47 | "# For instance, the code below will not be executed because it is commented.\n",
48 | "#print('just ignore me')"
49 | ]
50 | },
51 | {
52 | "cell_type": "code",
53 | "execution_count": null,
54 | "metadata": {},
55 | "outputs": [],
56 | "source": []
57 | },
58 | {
59 | "cell_type": "markdown",
60 | "metadata": {},
61 | "source": [
62 | "The output should look like this:\n",
63 | "\n",
64 | "![](\"media/jupyter_1.PNG\"/)
\n",
65 | "\n",
66 | "Congratulations! You've just ran your first jupyter notebook cell. Let's hope this is the first of many to come!\n",
67 | "\n",
68 | "If you're wondering what's the [4] in the image, it's the sequential execution number. It means that this was the fourth cell that was run in my notebook. You should have a [1] or [2] in your current notebook. Notice that running the same cell twice will also update the sequential number. Reselect the cell (by clicking on it) and click on \"Run\" in the Toolbar to see it being updated.\n",
69 | "\n",
70 | "Also, you do not have to run each cell one by one. Go ahead and type `print(\"I'm a professional programmer now\")` in the second code cell above and instead of clicking on \"Run\" in the Toolbar, click on \"Cell\" in the Menu bar and then click on \"Run All\". This will run all the cells in the notebook, it doesn't matter how many cells you have.\n",
71 | "\n",
72 | "You can also swap cell positions by clicking on the `up` or `down` arrows in the toolbar. Give it a try and swap the two cells above.\n",
73 | "\n",
74 | "But to be honest, I have never even used the `Run`command while I was in the academy. I would always restart the notebook and then run all cells.\n",
75 | "To understand why, let me introduce you to a new concept: the notebook kernel."
76 | ]
77 | },
78 | {
79 | "cell_type": "markdown",
80 | "metadata": {},
81 | "source": [
82 | "## 2. Notebook kernel\n",
83 | "\n",
84 | "The notebook kernel is the “computational engine” that executes the code contained in the jupyter notebook document. \n",
85 | "Since you chose to create the notebook with Python 3, the kernel executes Python code. There are kernels for other languages but in the prep course and in the academy, we will only be using Python 3.\n",
86 | "When you open a jupyter notebook document, the associated kernel is automatically launched. When the notebook is executed, the kernel performs the computation and produces the results. Depending on the type of computations, the kernel may consume significant CPU and RAM. However, for the prep course and the academy, you should be more than fine with 8GB of RAM."
87 | ]
88 | },
89 | {
90 | "cell_type": "markdown",
91 | "metadata": {},
92 | "source": [
93 | "Now, what does this have to do with restarting the notebook before running all cells? We'll almost there! Look at this example:\n",
94 | "\n",
95 | "![](\"media/jupyter_2.PNG\"/)
\n",
96 | "\n",
97 | "For the purpose of this example, just imagine that I'm storing the value 1 in a variable named `a`, the value 2 in a variable named `b` and the value 3 in a variable named `c`. And in the end, I'm printing them. It's straightforward, right?\n",
98 | "\n",
99 | "(What is a variable you ask? It is like a box to store things. We can store for instance numbers or text and later open the box - call the variable - and see what is inside.)"
100 | ]
101 | },
102 | {
103 | "cell_type": "markdown",
104 | "metadata": {},
105 | "source": [
106 | "Now, imagine that for some reason I later decide that I don't want to store the value 2 in variable `b`, in fact, I don't want to create the variable `b` at all. So, I delete that cell (you can do the same by clicking `Edit` -> `Delete Cells` in the Menu bar). Next to it is an option \"Undo Delete Cells\" in case you delete the wrong cell). I then decide to run all cells again. This is what I get: \n",
107 | "\n",
108 | "![](\"media/jupyter_3.PNG\"/)
"
109 | ]
110 | },
111 | {
112 | "cell_type": "markdown",
113 | "metadata": {},
114 | "source": [
115 | "This looks strange right? There is no `b` defined in my notebook, but it seems that the notebook somehow \"remembers\" that `b` used to store the value 2. Let's go ahead and print only `b`:\n",
116 | "\n",
117 | "![](\"media/jupyter_4.PNG\"/)
"
118 | ]
119 | },
120 | {
121 | "cell_type": "markdown",
122 | "metadata": {},
123 | "source": [
124 | "So, our suspicions are true! The lesson here is that the jupyter kernel stored the information \"b = 2\" in memory and deleting the cell that previously had this instruction **does not** erase this information from memory. So, if we really don't want this information to be stored in memory, what can we do?\n",
125 | "\n",
126 | "As I've told you before, this is why I restart the notebook before running all cells. Restarting the notebook will erase everything from the kernel memory and when you run all cells again **only** the current code cells will be considered. \n",
127 | "Let's try this! On the Menu bar select `Kernel` and then `Restart & Run All`. You should see something like this:\n",
128 | "\n",
129 | "![](\"media/jupyter_5.PNG\"/)
"
130 | ]
131 | },
132 | {
133 | "cell_type": "markdown",
134 | "metadata": {},
135 | "source": [
136 | "So now we have an error saying that `b` is not defined, which sounds about right since `b` is not defined anywhere in our notebook! This may seem like a simple detail and I'm sure some of you are thinking \"this is stupid and I would never do this\" but trust me: along the prep course or the academy this is a very common mistake to do and you can end up spending a lot of time in bugs that will trace back to this issue. \n",
137 | "\n",
138 | "Try this out on your own in the cells below (remember that to delete a cell you need to click `Edit` in the Menu bar and then `Delete Cells`):"
139 | ]
140 | },
141 | {
142 | "cell_type": "code",
143 | "execution_count": 2,
144 | "metadata": {},
145 | "outputs": [],
146 | "source": [
147 | "a = 1"
148 | ]
149 | },
150 | {
151 | "cell_type": "code",
152 | "execution_count": 3,
153 | "metadata": {},
154 | "outputs": [],
155 | "source": [
156 | "b = 2"
157 | ]
158 | },
159 | {
160 | "cell_type": "code",
161 | "execution_count": 4,
162 | "metadata": {},
163 | "outputs": [],
164 | "source": [
165 | "c = 3"
166 | ]
167 | },
168 | {
169 | "cell_type": "code",
170 | "execution_count": 5,
171 | "metadata": {},
172 | "outputs": [
173 | {
174 | "name": "stdout",
175 | "output_type": "stream",
176 | "text": [
177 | "1 2 3\n"
178 | ]
179 | }
180 | ],
181 | "source": [
182 | "print(a, b, c)"
183 | ]
184 | },
185 | {
186 | "cell_type": "markdown",
187 | "metadata": {},
188 | "source": [
189 | "### 2.1 Running cells\n",
190 | "When cells with code are running, a star appears next to them. Most of the code in this course will run in the blink of an eye, so you might not notice the star unless you create the programmer's nightmare, the infinite loop (which you can consider something like a rite of passage 😜 ). With more computationally intensive code, such as fitting a data science model, it will become noticeable.\n",
191 | "\n",
192 | "The code cell below was intentionally constructed to run for longer so that you can see the star. Try it out!"
193 | ]
194 | },
195 | {
196 | "cell_type": "code",
197 | "execution_count": 6,
198 | "metadata": {},
199 | "outputs": [],
200 | "source": [
201 | "import time\n",
202 | "time.sleep(5)"
203 | ]
204 | },
205 | {
206 | "cell_type": "markdown",
207 | "metadata": {},
208 | "source": [
209 | "Another indication that something in the notebook is running is the dot in the top right corner that turns black:\n",
210 | "\n",
211 | "![](\"media/jupyter_10.jpg\")
\n",
212 | "\n",
213 | "If you ever need to stop a running notebook, use `Kernel` -> `Interrupt`."
214 | ]
215 | },
216 | {
217 | "cell_type": "markdown",
218 | "metadata": {},
219 | "source": [
220 | "## 3. Shortcuts\n",
221 | "\n",
222 | "Last but not least, I'll teach you about some shortcuts that will greatly improve your productivity in jupyter notebooks. Up until now we've been using the edit mode of jupyter notebooks. A cell is in edit mode if it has the little green bar on the left side:\n",
223 | "\n",
224 | "![](\"media/jupyter_6.PNG\"/)
\n",
225 | "\n",
226 | "When you click on a cell or press `Enter` while the cell is selected, it goes into edit mode. However, if you press `Esc` or click outside of the gray area of the cell, you will see that the green bar turns blue - the cell will be in command mode:\n",
227 | "\n",
228 | "![](\"media/jupyter_7.PNG\"/)
\n",
229 | "\n",
230 | "Try it for yourself in the cell below:"
231 | ]
232 | },
233 | {
234 | "cell_type": "code",
235 | "execution_count": 7,
236 | "metadata": {},
237 | "outputs": [],
238 | "source": [
239 | "a = 1"
240 | ]
241 | },
242 | {
243 | "cell_type": "markdown",
244 | "metadata": {},
245 | "source": [
246 | "You have just learned the first two shortcuts - `Enter` and `Esc` - for switching between edit and command mode. While in command mode, you can use many more shortcuts that will make your life easier! \n",
247 | "\n",
248 | "- With the keyboard arrows `up` and `down` you can select different cells in your notebook. \n",
249 | "- Typing `A` will insert a cell above the cell that is selected and typing `B` will insert a cell below the cell that is selected. \n",
250 | "- Typing `D` two times in fast succession will delete the cell that is selected.\n",
251 | "- Using `Shift` and then the keyboard arrows `up` and `down` will select various code cells.\n",
252 | "- You can then type `Shift`+`M` to merge the cells."
253 | ]
254 | },
255 | {
256 | "cell_type": "markdown",
257 | "metadata": {},
258 | "source": [
259 | "### 3.1 Markdown cells\n",
260 | "If you type `M` the cell will change to markdown and typing `Y` will change the cell back to code. (You can see more options for cell types in `Cell` -> `Cell Type`).\n",
261 | "\n",
262 | "Markdown cells are cells that accept text with a specific syntax. They can be used to teach concepts (as I've been doing in this notebook) but during the academy I mostly used them to store information that was too important to go into a comment. Try it for yourself: change the cell below to markdown and copy paste the following text, then run the cell:\n",
263 | "\n",
264 | "\\# This is how you can create a header in markdown\n",
265 | "\n",
266 | "\\## This is a smaller header\n",
267 | "\n",
268 | "And to create a list:\n",
269 | "\n",
270 | "\\- Banana\n",
271 | "\n",
272 | "\\- Papaya\n",
273 | "\n",
274 | "\\- Orange"
275 | ]
276 | },
277 | {
278 | "cell_type": "code",
279 | "execution_count": null,
280 | "metadata": {},
281 | "outputs": [],
282 | "source": []
283 | },
284 | {
285 | "cell_type": "markdown",
286 | "metadata": {},
287 | "source": [
288 | "Now you've learned how to to create a header and a list using markdown cells! Check out this [guide](https://www.markdownguide.org/) to learn more about markdown syntax."
289 | ]
290 | },
291 | {
292 | "cell_type": "markdown",
293 | "metadata": {},
294 | "source": [
295 | "### 3.2 More useful shortcuts\n",
296 | "There are three shortcuts that come in handy for executing your code. The first one is `Ctrl`+`Enter` which will run the current cell. The next one is `Shift`+`Enter` which will run the current cell and move the focus to the cell below. In case you are executing the last cell in the notebook, a new cell will be created. And the last one, `Alt`+`Enter`, executes the current cell and creates a new cell under it so that you can easily continue coding. These will save you a lot of clicks on the Toolbar! \n",
297 | "\n",
298 | "Two other shortcuts that you will be using a lot: `Home` and `End`. They will take you to the top of the notebook (e.g. to see the table of contents) and to the bottom (e.g. to access the last cell of the exercise notebook to check out the information about grading and portal submission). Try it out! Notice that jumping to the top or bottom of the notebook does not affect the currently selected cell - it remains selected. If you'd like to go back to it, press the `up` or `down` arrow. This will select the cell above or below the current cell and move the focus back to where you came from.\n",
299 | "\n",
300 | "If you'd like to see all available shortcuts, press `H`.\n",
301 | "\n",
302 | "Sadly, my most used command `Restart & Run All` doesn't have a shortcut. What I've done, since I was using it so many times, was defining it myself. You can do that as well (and remember that this is just a personal tip) by clicking `Help` in the Menu bar and selecting `Edit Keyboard Shortcuts`. Search for the `restart kernel and run all cells` command and type `Ctrl-R` in the `add shortcut` field. Then click `OK` in the bottom right corner of the window. This way you can just press `Ctrl`+`R` instead of doing it manually.\n",
303 | "\n",
304 | "We've reached the end! Try to practice the shortcuts in this notebook and in the exercise notebook. If you have any doubts, ask on Slack! Good luck."
305 | ]
306 | }
307 | ],
308 | "metadata": {
309 | "kernelspec": {
310 | "display_name": "Python 3 (ipykernel)",
311 | "language": "python",
312 | "name": "python3"
313 | },
314 | "language_info": {
315 | "codemirror_mode": {
316 | "name": "ipython",
317 | "version": 3
318 | },
319 | "file_extension": ".py",
320 | "mimetype": "text/x-python",
321 | "name": "python",
322 | "nbconvert_exporter": "python",
323 | "pygments_lexer": "ipython3",
324 | "version": "3.8.15"
325 | }
326 | },
327 | "nbformat": 4,
328 | "nbformat_minor": 2
329 | }
330 |
--------------------------------------------------------------------------------
/00_Stage-1-Getting-Started/01-VSCode-Setup/02-Jupyter/Jupyter Notebook/README.md:
--------------------------------------------------------------------------------
1 | ## Jupyter Notebook
2 |
3 | Jupyter Notebook is a web-based interactive computational environment for creating jupyter notebook documents. A jupyter notebook document integrates code and its output into a single document that can also have visualizations, narrative text, mathematical equations, and other rich media. This promotes iterative and rapid development, making notebooks an increasingly popular choice for data scientists. For this reason, we will use jupyter notebooks not only in the python prep course but also in the data science academy.
4 |
5 | The purpose of this SLU is for you to become familiar with this tool.
6 |
7 | I will teach you the basics and some tips and tricks that I've used throughout the data science academy.
8 |
9 | However, the biggest takeaway is this:
10 |
11 | Whenever you're using your mouse to work with Jupyter Notebook, try to find a shortcut instead! If you do this enough times, you'll be a Jupyter Notebook pro in no time! Goodluck!
--------------------------------------------------------------------------------
/00_Stage-1-Getting-Started/01-VSCode-Setup/02-Jupyter/Jupyter Notebook/Updated%20Learning%20Notebook.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## 1. How to use Jupyter notebooks\n",
8 | "\n",
9 | "Let's begin by defining 3 sections of the Jupyter interface: in the following image, you can see the Menu bar in blue, the Toolbar in orange and a Code cell in yellow:\n",
10 | "\n",
11 | "Arewa Data Science Cohort 2.0
45 |Welcome to the Arewa Data Science Cohort Course repository! 🧑💻
46 |Your first step in this journey is to carefully read the steps in this tutorial. ⚠️ Important: Make sure to complete all the steps during the setup week. If you are struggling with any of the steps, tell us in the #setup channel on Telegram! In this tutorial, you’ll learn:
47 |-
48 |
- Telegram usage and etiquette specific to ArewaDS; 49 |
- How to set up your software environment; 50 |
- The weekly workflow to follow during the Cohort. 51 |
We have provided detailed instructions, but you might not understand all the details of the setup for now. It will become clearer as you proceed with the course. So don’t despair, put on your patience hat, and ask for help when needed. There’s light at the other end of the tunnel. :star2:
53 |1. How to use Telegram and how to ask for help
55 |First and foremost, we’ll talk about how to use our communication tool, Telegram. You will learn how to use it effectively and how to use it to ask for help. Click on the image to follow the link.
56 | 57 |
60 | 
61 | |
62 |
2. Initial Setup
68 |Please choose your operating system:
69 | 70 |
73 | 
74 | |
75 |
76 | 
77 | |
78 |
79 | 
80 | |
81 |
3. Setup Git and GitHub
87 |Click on the image to follow the link.
88 | 89 |
92 | 
93 | |
94 |
4. Setup for all operating systems - Python virtual environment
100 |Click on the image to follow the link.
101 | 102 |
105 | 
106 | |
107 |
5. VSCode Setup Guide
113 |Follow this guide to set up your Visual Studio Code (VSCode) environment for optimal performance and efficiency in your data science projects. Click on the image to access the detailed setup instructions.
114 | 115 |
118 | 
119 | |
120 |
6. Weekly workflow
126 |The workflow that you will follow every week with every new learning unit. Click on the image to follow the link.
127 | 128 |
131 | 
132 | |
133 |
21 | 
53 |
54 | 1. Click the "+" button in the upper-right corner of GitHub and select `New repository`.
55 | 2. Create a repository named `arewa-ds-workspace`.
56 | - Choose `Private` - this is your private work environment where nobody else will have access but you.
57 | - Initialize it with a `README`.
58 | - Select a Python `.gitignore` file. This file does exactly what it sounds like - it tells `git` which files to ignore when transfering files between your computer and `GitHub`.
59 |
60 |
61 | 
62 |
63 | You can also check [Creating a new repository](https://help.github.com/en/articles/creating-a-new-repository) on GitHub for help.
64 |
65 | ### Step 3: Clone Your Repository
66 |
67 | - Your workspace repository now exists on `GitHub`, but you also need a local copy (clone) on your computer.
68 |
69 | - To work on your projects locally, you need to clone your repository.
70 |
71 | - You will be working in the local repository and then transfer your work to your remote workspace repository on `GitHub`.
72 |
73 | **Step 1:** Open a terminal (or use one you've already opened).
74 |
75 | **Step 2:** Create a folder named `projects` by using the `mkdir` command. `mkdir` essentially stands for **m**a**k**e **dir**ectory. The tilde symbol `~` is a shortcut address for your home directory.
76 |
77 | ```bash
78 | mkdir ~/projects
79 | ```
80 |
81 | **Step 3:** Enter the folder by using the `cd` command. Did you know that `cd` means **c**hange **d**irectory? So basically changing to a different folder.
82 |
83 | ```bash
84 | cd ~/projects
85 | ```
86 |
87 | **Step 4:** You can now **clone** (create a local copy of) the `arewa-ds-workspace` repository you created on `GitHub`.
88 | Replace `
109 |
110 | ### 2.4 Clone the `Python-Programming-Fellowship` repository
111 |
112 | Let's clone the [`Python-Programming-Fellowship`](https://github.com/arewadataScience/python-programming-fellowship) repository. This is where all of the learning materials will be made available as the course progresses. You will be getting them (pulling) from there.
113 |
114 | **Step 1:** Open a terminal (or use one you've already opened) and enter the `projects` folder:
115 |
116 | ```bash
117 | cd ~/projects
118 | ```
119 |
120 | **Step 2:** Clone the Python-Programming-Fellowship repository (the repository you're reading right now!):
121 |
122 | ```bash
123 | git clone https://github.com/arewadataScience/python-programming-fellowship
124 | ```
125 |
126 | If you are using `ssh keys` for `GitHub`, use this command:
127 |
128 | ```bash
129 | git clone git@github.com:arewadataScience/python-programming-fellowship
130 | ```
131 |
132 | And you're done with setting `Git` and `GitHub`! Go back to the main menu and continue with step.
133 |
--------------------------------------------------------------------------------
/00_Stage-1-Getting-Started/guides/Windows_Subsystem_for_Linux_Installation_Guide_for_Windows_10.md:
--------------------------------------------------------------------------------
1 | # Windows Subsystem for Linux Installation Guide for Windows 10
2 |
3 | ## Make sure that Windows is up to date
4 |
5 | 1. Type `update` in your Windows search bar:
6 |
7 | 
8 |
9 | then click `Check for Updates`:
10 |
11 | 
12 |
13 | then download and install any updates that appear in the Windows Update menu (shown below):
14 |
15 | 
16 |
17 | After you're done installing those updates, please [check which OS build of Windows 10 you are running](https://support.microsoft.com/en-us/help/13443/windows-which-version-am-i-running), and if your OS build number is smaller that `19041.XXX`, then please keep coming back to Windows Update and installing updates until you have at least OS build `19041.XXX`. Then you may proceed with this guide.
18 |
19 | 
20 |
21 | ## Install the Windows Subsystem for Linux
22 |
23 | Before installing any Linux distributions for WSL, you must ensure that the `Windows Subsystem for Linux` optional feature is enabled:
24 |
25 | 1. Open `PowerShell` as Administrator by typing `PowerShell` in your Windows search bar:
26 |
27 | 
28 |
29 | and then clicking `Run as Administrator`:
30 |
31 | 
32 |
33 | 2. Then paste the following command in `PowerShell`:
34 |
35 | ```powershell
36 | Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux
37 | ```
38 |
39 | 
40 |
41 | and run it by pressing enter:
42 |
43 | 3. Restart your computer if asked to.
44 |
45 | ## Install Ubuntu
46 |
47 | 1. Open this link to the [Microsoft Store](https://www.microsoft.com/store/apps/9N9TNGVNDL3Q) and select `Get` to install `Ubuntu`.
48 |
49 | ## Launch Ubuntu
50 | To complete the initialization of your newly installed `Ubuntu`, launch a new instance. You can do this by typing `ubuntu` in your Windows search bar:
51 |
52 | 
53 |
54 | 
55 |
56 | The first time the newly installed `Ubuntu` runs, a `Console` window will open, and you'll be asked to wait for a minute or two for the installation to complete.
57 |
58 | > During this final stage of installation, `Ubuntu`'s files are de-compressed and stored on your PC, ready for use. This may take around a minute or more depending on the performance of your PC's storage devices. This initial installation phase is only required on the first launch - all future launches should take less than a second.
59 |
60 | ## Setting up a new Linux user account
61 |
62 | Once the installation is complete, you will be prompted to create a new user account (and its password).
63 |
64 | 
65 |
66 | This user account is for the normal non-admin user that you'll be logged-in by default when launching `Ubuntu`.
67 |
68 | > You can choose any username and password you wish - they have no bearing on your Windows username. Beware that when you type passwords in the terminal, you will not see what you are typing. This is a normal behaviour in Linux. Just type the password and hit Enter.
69 |
70 | When you open a new `Ubuntu` instance, you won't be prompted for your password, but **if you elevate a process using `sudo`, you will need to enter your password**, so make sure you choose a password you can easily remember! On `Ubuntu`, every user can do admin tasks such as installing software, but they have to use the magic `sudo` word and input the password. This tells `Ubuntu` that you will be acting as admin in the next moments.
71 |
72 | ## Opening the WSL terminal
73 |
74 | >⚠️ **Important**: From now on, every time we ask you to open a terminal, this is what you need to do. We'll refer to it just as `terminal` instead of `WSL terminal` or `Ubuntu terminal`.
75 |
76 | Whenever you want to use WSL, just type `ubuntu` in your Windows search bar.
77 |
78 | 
79 |
80 | Open it:
81 |
82 | 
83 |
84 | Then a `terminal` window will open that allows you to interact with `Ubuntu`.
85 |
86 | 
87 |
88 | ## Enable copy and paste keyboard shortcuts
89 |
90 | By default, the terminal does not allow the usual shortcuts for copying and pasting - you have to enable them first. In the upper left corner of the WSL terminal, click the orange circle:
91 |
92 | 
93 |
94 | then click `Properties`:
95 |
96 | 
97 |
98 | Then under the `Options` tab, in the `Edit Options` section, make sure that `Use Ctrl+Shift+C/V as Copy/Paste` in enabled and click `OK`:
99 |
100 | 
101 |
102 | ## Update & upgrade Ubuntu's software packages
103 |
104 | Most Linux distributions ship with an empty/minimal software package catalog. We strongly recommend regularly updating your package catalog, and upgrading your installed packages using the appropriate package manager. On `Ubuntu`, you use the `apt` package manager. The following command will check for software updates and install them:
105 |
106 | ```bash
107 | sudo apt update && sudo apt upgrade
108 | ```
109 |
110 | > Windows does not automatically update or upgrade your Linux distribution. This is a task that the Linux users prefer to control themselves.
111 |
112 | ## How to open Windows File Explorer to manipulate files inside WSL
113 |
114 | If you’d like to use `Windows File Explorer` to manipulate the files in WSL, just type this in the `terminal`. **(Don't forget to include the dot! The dot means "current directory")**:
115 |
116 | ```console
117 | explorer.exe .
118 | ```
119 |
120 | The `Windows Explorer` should pop up:
121 |
122 | 
123 |
124 | Keep in mind that you should manipulate files and create directories inside your `Ubuntu-18.04/home/
, open the `Go` menu, choose the option `Go to folder...`
17 |
18 | 
19 |
20 | Now paste the path to the `ds-prep-course-2023` repository: `~/projects/ds-prep-course-2023`, then click `Go`.
21 |
22 | 
23 |
--------------------------------------------------------------------------------
/00_Stage-1-Getting-Started/image.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/arewadataScience/python-programming-fellowship/2a6cca48b73573dade298db5c44168b8be7f6082/00_Stage-1-Getting-Started/image.png
--------------------------------------------------------------------------------
/00_Stage-1-Getting-Started/macOS.md:
--------------------------------------------------------------------------------
1 | # Set-up instructions for MacOS
2 |
3 | # Objective
4 |
5 | Welcome to the MacOS setup guide for the Arewa Data Science Fellowship. The objective of this tutorial is to guide you through the essential steps to configure your MacOS environment for data science work. By the end of this tutorial, you will have successfully installed and set up key tools including [Homebrew](https://brew.sh/), [Git](https://git-scm.com/), and [Python](https://www.python.org/). These tools are fundamental for your journey in data science and will be used extensively throughout the fellowship. You'll learn how to set up your computer - follow the link to your MacOS type ➡️
6 |
7 | - [MacOS Intel Setup](#MacOS-Intel-Setup)
8 | - [MacOS M1 Setup](#MacOS-M1-Setup)
9 |
10 | ### MacOS Intel Setup
11 |
12 | Some of the steps in the following sections will require `Homebrew` for MacOS. `Homebrew` is a package manager - it helps you installing software. Installing `Homebrew` will make it easier to install software that we will use later on.
13 |
14 | **Step 1:** Open a terminal in one of the following ways:
15 | * In Finder 
, open the `/Applications/Utilities` folder, then double-click `Terminal`.
16 | * Press cmd + space then type `terminal` and press enter.
17 |
18 | The terminal should now be open:
19 |
20 | 
21 |
22 | **Step 2:** To install `Homebrew` for MacOS, copy and paste the following line in the terminal:
23 |
24 | ```bash
25 | /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"
26 | ```
27 |
28 | **Step 2.1:** Sometimes it's necessary to install `xcode command line utils`. To do so, execute the following command before installing `Homebrew`:
29 |
30 | ```bash
31 | xcode-select --install
32 | ```
33 |
34 | You may be prompted to install the `Command Line Developers Tools`. Confirm and once it finishes, continue installing `Homebrew` by pressing enter again.
35 |
36 | **Step 3:** Open a terminal and run the following command to update `Homebrew`. The verbose option means that `Homebrew` will tell you what it's doing - you will see a lot of text output in your terminal:
37 |
38 | ```bash
39 | brew update --verbose
40 | ```
41 |
42 | **Step 4:** Now run the following command to install `git`. `Git` is a version control software that facilitates collaboration of people working together on the same code and keeps track of the versions as the code changes. You will learn more about `git` in this course.
43 |
44 | ```bash
45 | brew install git
46 | ```
47 |
48 | **Step 5:** Now run the following command to install `Python 3.9`:
49 |
50 | ```bash
51 | brew install python@3.9
52 | ```
53 |
54 | **Step 6:** then run the following command to set the default `python3` version to 3.9:
55 |
56 | ```bash
57 | brew link python@3.9
58 | ```
59 |
60 | And you're done! Go back continue with setting up Git and GitHub in step 3.
61 |
62 | ### MacOS M1 Setup
63 |
64 | So you've got the new M1 and you're super happy with how fast it is. Unfortunately dealing with Apple silicon requires a little detour. But don't worry, we'll be able to get there in the end.
65 |
66 | **Step 1:** Open a terminal in one of the following ways:
67 | * In Finder 
41 | 
71 | 
168 | 
181 | 
193 | 
215 | 
228 | 
249 |