![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
![\"SRTTU\"](\"http://akhavanpour.ir/notebook/images/srttu.gif\")
"
8 | ]
9 | },
10 | {
11 | "cell_type": "markdown",
12 | "metadata": {},
13 | "source": [
14 | "# SciKit Learn Preprocessing Overview"
15 | ]
16 | },
17 | {
18 | "cell_type": "code",
19 | "execution_count": null,
20 | "metadata": {
21 | "collapsed": true
22 | },
23 | "outputs": [],
24 | "source": [
25 | "import numpy as np"
26 | ]
27 | },
28 | {
29 | "cell_type": "code",
30 | "execution_count": null,
31 | "metadata": {
32 | "collapsed": true
33 | },
34 | "outputs": [],
35 | "source": [
36 | "from sklearn.preprocessing import MinMaxScaler"
37 | ]
38 | },
39 | {
40 | "cell_type": "code",
41 | "execution_count": null,
42 | "metadata": {
43 | "collapsed": true
44 | },
45 | "outputs": [],
46 | "source": [
47 | "data = np.random.randint(0,100,(10,2))"
48 | ]
49 | },
50 | {
51 | "cell_type": "code",
52 | "execution_count": null,
53 | "metadata": {
54 | "collapsed": false
55 | },
56 | "outputs": [],
57 | "source": [
58 | "data"
59 | ]
60 | },
61 | {
62 | "cell_type": "code",
63 | "execution_count": null,
64 | "metadata": {
65 | "collapsed": true
66 | },
67 | "outputs": [],
68 | "source": [
69 | "scaler_model = MinMaxScaler()"
70 | ]
71 | },
72 | {
73 | "cell_type": "code",
74 | "execution_count": null,
75 | "metadata": {
76 | "collapsed": false
77 | },
78 | "outputs": [],
79 | "source": [
80 | "scaler_model.fit(data)"
81 | ]
82 | },
83 | {
84 | "cell_type": "code",
85 | "execution_count": null,
86 | "metadata": {
87 | "collapsed": false
88 | },
89 | "outputs": [],
90 | "source": [
91 | "scaler_model.transform(data)"
92 | ]
93 | },
94 | {
95 | "cell_type": "code",
96 | "execution_count": null,
97 | "metadata": {
98 | "collapsed": false
99 | },
100 | "outputs": [],
101 | "source": [
102 | "# In one step\n",
103 | "result = scaler_model.fit_transform(data)"
104 | ]
105 | },
106 | {
107 | "cell_type": "code",
108 | "execution_count": null,
109 | "metadata": {
110 | "collapsed": false
111 | },
112 | "outputs": [],
113 | "source": [
114 | "result"
115 | ]
116 | },
117 | {
118 | "cell_type": "code",
119 | "execution_count": null,
120 | "metadata": {
121 | "collapsed": false
122 | },
123 | "outputs": [],
124 | "source": [
125 | "import pandas as pd"
126 | ]
127 | },
128 | {
129 | "cell_type": "code",
130 | "execution_count": null,
131 | "metadata": {
132 | "collapsed": true
133 | },
134 | "outputs": [],
135 | "source": [
136 | "data = pd.DataFrame(data=np.random.randint(0,101,(50,4)),columns=['f1','f2','f3','label'])"
137 | ]
138 | },
139 | {
140 | "cell_type": "code",
141 | "execution_count": null,
142 | "metadata": {
143 | "collapsed": false
144 | },
145 | "outputs": [],
146 | "source": [
147 | "data.head()"
148 | ]
149 | },
150 | {
151 | "cell_type": "code",
152 | "execution_count": null,
153 | "metadata": {
154 | "collapsed": false
155 | },
156 | "outputs": [],
157 | "source": [
158 | "x = data[['f1','f2','f3']] # Alternatively x = data.drop('label',axis=1)\n",
159 | "y = data['label']"
160 | ]
161 | },
162 | {
163 | "cell_type": "code",
164 | "execution_count": null,
165 | "metadata": {
166 | "collapsed": false
167 | },
168 | "outputs": [],
169 | "source": [
170 | "from sklearn.model_selection import train_test_split"
171 | ]
172 | },
173 | {
174 | "cell_type": "code",
175 | "execution_count": null,
176 | "metadata": {
177 | "collapsed": true
178 | },
179 | "outputs": [],
180 | "source": [
181 | "X_train, X_test, y_train, y_test = train_test_split(x,y,test_size=0.3,random_state=101)"
182 | ]
183 | },
184 | {
185 | "cell_type": "code",
186 | "execution_count": null,
187 | "metadata": {
188 | "collapsed": false
189 | },
190 | "outputs": [],
191 | "source": [
192 | "X_train.shape"
193 | ]
194 | },
195 | {
196 | "cell_type": "code",
197 | "execution_count": null,
198 | "metadata": {
199 | "collapsed": false
200 | },
201 | "outputs": [],
202 | "source": [
203 | "X_test.shape"
204 | ]
205 | },
206 | {
207 | "cell_type": "code",
208 | "execution_count": null,
209 | "metadata": {
210 | "collapsed": false
211 | },
212 | "outputs": [],
213 | "source": [
214 | "y_train.shape"
215 | ]
216 | },
217 | {
218 | "cell_type": "code",
219 | "execution_count": null,
220 | "metadata": {
221 | "collapsed": false
222 | },
223 | "outputs": [],
224 | "source": [
225 | "y_test.shape"
226 | ]
227 | },
228 | {
229 | "cell_type": "markdown",
230 | "metadata": {},
231 | "source": [
232 | "## Great Job!"
233 | ]
234 | },
235 | {
236 | "cell_type": "markdown",
237 | "metadata": {
238 | "collapsed": true
239 | },
240 | "source": [
241 | ""
8 | ]
9 | },
10 | {
11 | "cell_type": "code",
12 | "execution_count": null,
13 | "metadata": {
14 | "collapsed": true
15 | },
16 | "outputs": [],
17 | "source": [
18 | "import numpy as np"
19 | ]
20 | },
21 | {
22 | "cell_type": "markdown",
23 | "metadata": {},
24 | "source": [
25 | "## Creating Arrays"
26 | ]
27 | },
28 | {
29 | "cell_type": "code",
30 | "execution_count": null,
31 | "metadata": {
32 | "collapsed": true
33 | },
34 | "outputs": [],
35 | "source": [
36 | "my_list = [0,1,2,3,4]"
37 | ]
38 | },
39 | {
40 | "cell_type": "code",
41 | "execution_count": null,
42 | "metadata": {
43 | "collapsed": false
44 | },
45 | "outputs": [],
46 | "source": [
47 | "type(my_list)"
48 | ]
49 | },
50 | {
51 | "cell_type": "markdown",
52 | "metadata": {
53 | "collapsed": true
54 | },
55 | "source": [
56 | "# arr = np.array(my_list)"
57 | ]
58 | },
59 | {
60 | "cell_type": "code",
61 | "execution_count": null,
62 | "metadata": {
63 | "collapsed": false
64 | },
65 | "outputs": [],
66 | "source": [
67 | "np.arange(0,10)"
68 | ]
69 | },
70 | {
71 | "cell_type": "code",
72 | "execution_count": null,
73 | "metadata": {
74 | "collapsed": false
75 | },
76 | "outputs": [],
77 | "source": [
78 | "np.arange(0,10,2)"
79 | ]
80 | },
81 | {
82 | "cell_type": "code",
83 | "execution_count": null,
84 | "metadata": {
85 | "collapsed": false
86 | },
87 | "outputs": [],
88 | "source": [
89 | "np.zeros((5,5))+5\n"
90 | ]
91 | },
92 | {
93 | "cell_type": "code",
94 | "execution_count": null,
95 | "metadata": {
96 | "collapsed": false
97 | },
98 | "outputs": [],
99 | "source": [
100 | "np.ones((2,4))*7"
101 | ]
102 | },
103 | {
104 | "cell_type": "code",
105 | "execution_count": null,
106 | "metadata": {
107 | "collapsed": false
108 | },
109 | "outputs": [],
110 | "source": [
111 | "np.random.randint(0,10)"
112 | ]
113 | },
114 | {
115 | "cell_type": "code",
116 | "execution_count": null,
117 | "metadata": {
118 | "collapsed": false
119 | },
120 | "outputs": [],
121 | "source": [
122 | "np.random.randint(0,10,(3,3))"
123 | ]
124 | },
125 | {
126 | "cell_type": "code",
127 | "execution_count": null,
128 | "metadata": {
129 | "collapsed": false
130 | },
131 | "outputs": [],
132 | "source": [
133 | "np.linspace(0,10,6)"
134 | ]
135 | },
136 | {
137 | "cell_type": "code",
138 | "execution_count": null,
139 | "metadata": {
140 | "collapsed": false
141 | },
142 | "outputs": [],
143 | "source": [
144 | "np.linspace(0,10,101)"
145 | ]
146 | },
147 | {
148 | "cell_type": "markdown",
149 | "metadata": {},
150 | "source": [
151 | "## Operations"
152 | ]
153 | },
154 | {
155 | "cell_type": "code",
156 | "execution_count": null,
157 | "metadata": {
158 | "collapsed": true
159 | },
160 | "outputs": [],
161 | "source": [
162 | "np.random.seed(101) # watch video for details\n",
163 | "arr = np.random.randint(0,100,10)"
164 | ]
165 | },
166 | {
167 | "cell_type": "code",
168 | "execution_count": null,
169 | "metadata": {
170 | "collapsed": false
171 | },
172 | "outputs": [],
173 | "source": [
174 | "arr"
175 | ]
176 | },
177 | {
178 | "cell_type": "code",
179 | "execution_count": null,
180 | "metadata": {
181 | "collapsed": true
182 | },
183 | "outputs": [],
184 | "source": [
185 | "arr2 = np.random.randint(0,100,10)"
186 | ]
187 | },
188 | {
189 | "cell_type": "code",
190 | "execution_count": null,
191 | "metadata": {
192 | "collapsed": false
193 | },
194 | "outputs": [],
195 | "source": [
196 | "arr2"
197 | ]
198 | },
199 | {
200 | "cell_type": "code",
201 | "execution_count": null,
202 | "metadata": {
203 | "collapsed": false
204 | },
205 | "outputs": [],
206 | "source": [
207 | "arr.max()"
208 | ]
209 | },
210 | {
211 | "cell_type": "code",
212 | "execution_count": null,
213 | "metadata": {
214 | "collapsed": false
215 | },
216 | "outputs": [],
217 | "source": [
218 | "arr.min()"
219 | ]
220 | },
221 | {
222 | "cell_type": "code",
223 | "execution_count": null,
224 | "metadata": {
225 | "collapsed": false
226 | },
227 | "outputs": [],
228 | "source": [
229 | "arr.mean()"
230 | ]
231 | },
232 | {
233 | "cell_type": "code",
234 | "execution_count": null,
235 | "metadata": {
236 | "collapsed": false
237 | },
238 | "outputs": [],
239 | "source": [
240 | "arr.argmin()"
241 | ]
242 | },
243 | {
244 | "cell_type": "code",
245 | "execution_count": null,
246 | "metadata": {
247 | "collapsed": false
248 | },
249 | "outputs": [],
250 | "source": [
251 | "arr.argmax()"
252 | ]
253 | },
254 | {
255 | "cell_type": "code",
256 | "execution_count": null,
257 | "metadata": {
258 | "collapsed": false
259 | },
260 | "outputs": [],
261 | "source": [
262 | "arr.reshape(2,5)"
263 | ]
264 | },
265 | {
266 | "cell_type": "markdown",
267 | "metadata": {},
268 | "source": [
269 | "## Indexing"
270 | ]
271 | },
272 | {
273 | "cell_type": "code",
274 | "execution_count": null,
275 | "metadata": {
276 | "collapsed": true
277 | },
278 | "outputs": [],
279 | "source": [
280 | "mat = np.arange(0,100).reshape(10,10)"
281 | ]
282 | },
283 | {
284 | "cell_type": "code",
285 | "execution_count": null,
286 | "metadata": {
287 | "collapsed": false
288 | },
289 | "outputs": [],
290 | "source": [
291 | "mat"
292 | ]
293 | },
294 | {
295 | "cell_type": "code",
296 | "execution_count": null,
297 | "metadata": {
298 | "collapsed": true
299 | },
300 | "outputs": [],
301 | "source": [
302 | "row = 0\n",
303 | "col = 1"
304 | ]
305 | },
306 | {
307 | "cell_type": "code",
308 | "execution_count": null,
309 | "metadata": {
310 | "collapsed": false
311 | },
312 | "outputs": [],
313 | "source": [
314 | "mat[row,col]"
315 | ]
316 | },
317 | {
318 | "cell_type": "code",
319 | "execution_count": null,
320 | "metadata": {
321 | "collapsed": false
322 | },
323 | "outputs": [],
324 | "source": [
325 | "# With Slices\n",
326 | "mat[:,col:col+1]"
327 | ]
328 | },
329 | {
330 | "cell_type": "code",
331 | "execution_count": null,
332 | "metadata": {
333 | "collapsed": false
334 | },
335 | "outputs": [],
336 | "source": [
337 | "mat[row,:]"
338 | ]
339 | },
340 | {
341 | "cell_type": "code",
342 | "execution_count": null,
343 | "metadata": {
344 | "collapsed": false
345 | },
346 | "outputs": [],
347 | "source": [
348 | "mat[0:3,0:3]"
349 | ]
350 | },
351 | {
352 | "cell_type": "markdown",
353 | "metadata": {},
354 | "source": [
355 | "## Masking"
356 | ]
357 | },
358 | {
359 | "cell_type": "code",
360 | "execution_count": null,
361 | "metadata": {
362 | "collapsed": false
363 | },
364 | "outputs": [],
365 | "source": [
366 | "a=mat > 50"
367 | ]
368 | },
369 | {
370 | "cell_type": "code",
371 | "execution_count": null,
372 | "metadata": {
373 | "collapsed": false
374 | },
375 | "outputs": [],
376 | "source": [
377 | "mat[mat<30]\n"
378 | ]
379 | },
380 | {
381 | "cell_type": "markdown",
382 | "metadata": {},
383 | "source": [
384 | "# Great Job!"
385 | ]
386 | }
387 | ],
388 | "metadata": {
389 | "anaconda-cloud": {},
390 | "kernelspec": {
391 | "display_name": "Python [conda env:virtual_platform]",
392 | "language": "python",
393 | "name": "conda-env-virtual_platform-py"
394 | },
395 | "language_info": {
396 | "codemirror_mode": {
397 | "name": "ipython",
398 | "version": 3
399 | },
400 | "file_extension": ".py",
401 | "mimetype": "text/x-python",
402 | "name": "python",
403 | "nbconvert_exporter": "python",
404 | "pygments_lexer": "ipython3",
405 | "version": "3.5.4"
406 | }
407 | },
408 | "nbformat": 4,
409 | "nbformat_minor": 2
410 | }
411 |
--------------------------------------------------------------------------------
/7-Pandas_Intro.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {
6 | "colab_type": "text",
7 | "id": "view-in-github"
8 | },
9 | "source": [
10 | ""
11 | ]
12 | },
13 | {
14 | "cell_type": "markdown",
15 | "metadata": {
16 | "colab_type": "text",
17 | "id": "8GLCM_xrxJdc"
18 | },
19 | "source": [
20 | "Let's start by importing Pandas. Click on a cell to activate it. Press Shift + Enter to execute. Cells should be executed in order."
21 | ]
22 | },
23 | {
24 | "cell_type": "code",
25 | "execution_count": 0,
26 | "metadata": {
27 | "colab": {},
28 | "colab_type": "code",
29 | "id": "U_5zMEGZL96I"
30 | },
31 | "outputs": [],
32 | "source": [
33 | "import pandas as pd"
34 | ]
35 | },
36 | {
37 | "cell_type": "markdown",
38 | "metadata": {
39 | "colab_type": "text",
40 | "id": "7qQ1n2fkx234"
41 | },
42 | "source": [
43 | "## Load / Create Data Frame\n",
44 | "We can read CSV or excel files to import data. We can also create dataframes programatically like this:"
45 | ]
46 | },
47 | {
48 | "cell_type": "code",
49 | "execution_count": 0,
50 | "metadata": {
51 | "colab": {},
52 | "colab_type": "code",
53 | "id": "yyFj31jcMmH6"
54 | },
55 | "outputs": [],
56 | "source": [
57 | "df = pd.DataFrame({'Artist':['Billie Holiday','Jimi Hendrix', 'Miles Davis', 'SIA'],\n",
58 | " 'Genre': ['Jazz', 'Rock', 'Jazz', 'Pop'],\n",
59 | " 'Listeners': [1300000, 2700000, 1500000, 2000000],\n",
60 | " 'Plays': [27000000, 70000000, 48000000, 74000000]})"
61 | ]
62 | },
63 | {
64 | "cell_type": "markdown",
65 | "metadata": {
66 | "colab_type": "text",
67 | "id": "wXj4OuOrxwJm"
68 | },
69 | "source": [
70 | " The variable `df` now contains a dataframe. Executing this cell shows the contents of the dataframe"
71 | ]
72 | },
73 | {
74 | "cell_type": "code",
75 | "execution_count": 0,
76 | "metadata": {
77 | "colab": {},
78 | "colab_type": "code",
79 | "id": "WF4_LVYOO__m"
80 | },
81 | "outputs": [],
82 | "source": [
83 | "df"
84 | ]
85 | },
86 | {
87 | "cell_type": "markdown",
88 | "metadata": {
89 | "colab_type": "text",
90 | "id": "6LUcXFMKyF6z"
91 | },
92 | "source": [
93 | "## Selection\n",
94 | "We can select any column using its label:"
95 | ]
96 | },
97 | {
98 | "cell_type": "code",
99 | "execution_count": 0,
100 | "metadata": {
101 | "colab": {},
102 | "colab_type": "code",
103 | "id": "sTNHtQz3Mu_K"
104 | },
105 | "outputs": [],
106 | "source": [
107 | "df['Artist']"
108 | ]
109 | },
110 | {
111 | "cell_type": "markdown",
112 | "metadata": {
113 | "colab_type": "text",
114 | "id": "UeH1ClC3yOJy"
115 | },
116 | "source": [
117 | "We can select one or multiple rows using their numbers (inclusive of both bounding row numbers):"
118 | ]
119 | },
120 | {
121 | "cell_type": "code",
122 | "execution_count": 0,
123 | "metadata": {
124 | "colab": {},
125 | "colab_type": "code",
126 | "id": "41MpPCPwM0AR"
127 | },
128 | "outputs": [],
129 | "source": [
130 | "df.loc[1:3]"
131 | ]
132 | },
133 | {
134 | "cell_type": "code",
135 | "execution_count": 0,
136 | "metadata": {
137 | "colab": {},
138 | "colab_type": "code",
139 | "id": "fhOMUtTNPnc0"
140 | },
141 | "outputs": [],
142 | "source": [
143 | "# Exercise: Select only row #0\n",
144 | "\n"
145 | ]
146 | },
147 | {
148 | "cell_type": "markdown",
149 | "metadata": {
150 | "colab_type": "text",
151 | "id": "7eeFjuAUyTDj"
152 | },
153 | "source": [
154 | "We can select any slice of the table using a both column label and row numbers using loc:"
155 | ]
156 | },
157 | {
158 | "cell_type": "code",
159 | "execution_count": 0,
160 | "metadata": {
161 | "colab": {},
162 | "colab_type": "code",
163 | "id": "p7EPN96RPHQt"
164 | },
165 | "outputs": [],
166 | "source": [
167 | "df.loc[1:3,['Artist']]"
168 | ]
169 | },
170 | {
171 | "cell_type": "code",
172 | "execution_count": 0,
173 | "metadata": {
174 | "colab": {},
175 | "colab_type": "code",
176 | "id": "ov_6TtCvPubJ"
177 | },
178 | "outputs": [],
179 | "source": [
180 | "# Exercise: Select 'Artist' and 'Plays' for rows #1 and #2\n"
181 | ]
182 | },
183 | {
184 | "cell_type": "markdown",
185 | "metadata": {
186 | "colab_type": "text",
187 | "id": "GeuS62DoyXlJ"
188 | },
189 | "source": [
190 | "## Filtering\n",
191 | "Now it gets more interesting. We can easily filter rows using the values of a specific row. For example, here are our jazz musicians:"
192 | ]
193 | },
194 | {
195 | "cell_type": "code",
196 | "execution_count": 0,
197 | "metadata": {
198 | "colab": {},
199 | "colab_type": "code",
200 | "id": "ax8qDMHfPQmP"
201 | },
202 | "outputs": [],
203 | "source": [
204 | "df[df['Genre'] == \"Jazz\" ]"
205 | ]
206 | },
207 | {
208 | "cell_type": "code",
209 | "execution_count": 0,
210 | "metadata": {
211 | "colab": {},
212 | "colab_type": "code",
213 | "id": "Surgh6XVRmlT"
214 | },
215 | "outputs": [],
216 | "source": [
217 | "# Exercise: Select the row where the Genre is 'Rock'\n",
218 | "\n"
219 | ]
220 | },
221 | {
222 | "cell_type": "markdown",
223 | "metadata": {
224 | "colab_type": "text",
225 | "id": "a33J488lyeFj"
226 | },
227 | "source": [
228 | "Here are the artists who have more than 1,800,000 listeners:"
229 | ]
230 | },
231 | {
232 | "cell_type": "code",
233 | "execution_count": 0,
234 | "metadata": {
235 | "colab": {},
236 | "colab_type": "code",
237 | "id": "H1Ld-RXQPTLL"
238 | },
239 | "outputs": [],
240 | "source": [
241 | "df[df['Listeners'] > 1800000 ]"
242 | ]
243 | },
244 | {
245 | "cell_type": "code",
246 | "execution_count": 0,
247 | "metadata": {
248 | "colab": {},
249 | "colab_type": "code",
250 | "id": "8XLaLBKORva4"
251 | },
252 | "outputs": [],
253 | "source": [
254 | "# Exercise: Select the rows where 'Plays' is less than 50,000,000\n",
255 | "\n"
256 | ]
257 | },
258 | {
259 | "cell_type": "markdown",
260 | "metadata": {
261 | "colab_type": "text",
262 | "id": "MPeYsXStyuwA"
263 | },
264 | "source": [
265 | "## Grouping"
266 | ]
267 | },
268 | {
269 | "cell_type": "code",
270 | "execution_count": 0,
271 | "metadata": {
272 | "colab": {},
273 | "colab_type": "code",
274 | "id": "qPG_jFSdPMF5"
275 | },
276 | "outputs": [],
277 | "source": [
278 | "df.groupby('Genre').sum()"
279 | ]
280 | },
281 | {
282 | "cell_type": "code",
283 | "execution_count": 0,
284 | "metadata": {
285 | "colab": {},
286 | "colab_type": "code",
287 | "id": "kb5smli-PVE3"
288 | },
289 | "outputs": [],
290 | "source": [
291 | "# Exercise: Group by Genre, use mean() as the aggregation function \n"
292 | ]
293 | },
294 | {
295 | "cell_type": "code",
296 | "execution_count": 0,
297 | "metadata": {
298 | "colab": {},
299 | "colab_type": "code",
300 | "id": "g2IFgCF4Rg48"
301 | },
302 | "outputs": [],
303 | "source": [
304 | "# Exercise: Group by Genre, use max() as the aggregation function \n"
305 | ]
306 | },
307 | {
308 | "cell_type": "markdown",
309 | "metadata": {},
310 | "source": [
311 | "source:\n",
312 | " https://github.com/jalammar/pandas-intro/blob/master/Pandas_Intro.ipynb"
313 | ]
314 | }
315 | ],
316 | "metadata": {
317 | "colab": {
318 | "collapsed_sections": [],
319 | "include_colab_link": true,
320 | "name": "Pandas Intro.ipynb",
321 | "provenance": [],
322 | "version": "0.3.2"
323 | },
324 | "kernelspec": {
325 | "display_name": "Python 3",
326 | "language": "python",
327 | "name": "python3"
328 | },
329 | "language_info": {
330 | "codemirror_mode": {
331 | "name": "ipython",
332 | "version": 3
333 | },
334 | "file_extension": ".py",
335 | "mimetype": "text/x-python",
336 | "name": "python",
337 | "nbconvert_exporter": "python",
338 | "pygments_lexer": "ipython3",
339 | "version": "3.8.5"
340 | }
341 | },
342 | "nbformat": 4,
343 | "nbformat_minor": 1
344 | }
345 |
--------------------------------------------------------------------------------
/7-1-Pandas_review.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | ""
8 | ]
9 | },
10 | {
11 | "cell_type": "code",
12 | "execution_count": 3,
13 | "metadata": {
14 | "collapsed": true
15 | },
16 | "outputs": [],
17 | "source": [
18 | "import pandas as pd"
19 | ]
20 | },
21 | {
22 | "cell_type": "code",
23 | "execution_count": 4,
24 | "metadata": {
25 | "collapsed": false
26 | },
27 | "outputs": [],
28 | "source": [
29 | "df = pd.read_csv('salaries.csv')"
30 | ]
31 | },
32 | {
33 | "cell_type": "code",
34 | "execution_count": 5,
35 | "metadata": {
36 | "collapsed": false
37 | },
38 | "outputs": [
39 | {
40 | "data": {
41 | "text/html": [
42 | "| \n", 47 | " | Name | \n", 48 | "Salary | \n", 49 | "Age | \n", 50 | "
|---|---|---|---|
| 0 | \n", 55 | "John | \n", 56 | "50000 | \n", 57 | "34 | \n", 58 | "
| 1 | \n", 61 | "Sally | \n", 62 | "120000 | \n", 63 | "45 | \n", 64 | "
| 2 | \n", 67 | "Alyssa | \n", 68 | "80000 | \n", 69 | "27 | \n", 70 | "
| \n", 156 | " | Name | \n", 157 | "Age | \n", 158 | "
|---|---|---|
| 0 | \n", 163 | "John | \n", 164 | "34 | \n", 165 | "
| 1 | \n", 168 | "Sally | \n", 169 | "45 | \n", 170 | "
| 2 | \n", 173 | "Alyssa | \n", 174 | "27 | \n", 175 | "
| \n", 319 | " | Name | \n", 320 | "Salary | \n", 321 | "Age | \n", 322 | "
|---|---|---|---|
| 2 | \n", 327 | "Alyssa | \n", 328 | "80000 | \n", 329 | "27 | \n", 330 | "
| \n", 364 | " | Name | \n", 365 | "Salary | \n", 366 | "Age | \n", 367 | "
|---|---|---|---|
| 0 | \n", 372 | "John | \n", 373 | "50000 | \n", 374 | "34 | \n", 375 | "
| 1 | \n", 378 | "Sally | \n", 379 | "120000 | \n", 380 | "45 | \n", 381 | "
"
8 | ]
9 | },
10 | {
11 | "cell_type": "code",
12 | "execution_count": null,
13 | "metadata": {
14 | "collapsed": true
15 | },
16 | "outputs": [],
17 | "source": [
18 | "\n",
19 | "import numpy as np \n",
20 | "import matplotlib.pyplot as plt\n"
21 | ]
22 | },
23 | {
24 | "cell_type": "markdown",
25 | "metadata": {},
26 | "source": [
27 | " Consider the list **a **, the list contains three nested lists **each of equal size**. "
28 | ]
29 | },
30 | {
31 | "cell_type": "code",
32 | "execution_count": null,
33 | "metadata": {
34 | "collapsed": false
35 | },
36 | "outputs": [],
37 | "source": [
38 | "a=[[11,12,13],[21,22,23],[31,32,33]]\n",
39 | "a"
40 | ]
41 | },
42 | {
43 | "cell_type": "markdown",
44 | "metadata": {},
45 | "source": [
46 | " We can cast the list to a numpy array as follow"
47 | ]
48 | },
49 | {
50 | "cell_type": "code",
51 | "execution_count": null,
52 | "metadata": {
53 | "collapsed": false
54 | },
55 | "outputs": [],
56 | "source": [
57 | "#every elment if of the same type \n",
58 | "A=np.array(a)\n",
59 | "A"
60 | ]
61 | },
62 | {
63 | "cell_type": "markdown",
64 | "metadata": {},
65 | "source": [
66 | "We can use the attribute **ndim** to obtain the number of axes or dimensions referred to as the rank. "
67 | ]
68 | },
69 | {
70 | "cell_type": "code",
71 | "execution_count": null,
72 | "metadata": {
73 | "collapsed": false
74 | },
75 | "outputs": [],
76 | "source": [
77 | "A.ndim"
78 | ]
79 | },
80 | {
81 | "cell_type": "markdown",
82 | "metadata": {},
83 | "source": [
84 | " Attribute **shape** returns a tuple corresponding to the size or number of each dimension."
85 | ]
86 | },
87 | {
88 | "cell_type": "code",
89 | "execution_count": null,
90 | "metadata": {
91 | "collapsed": false
92 | },
93 | "outputs": [],
94 | "source": [
95 | "A.shape"
96 | ]
97 | },
98 | {
99 | "cell_type": "markdown",
100 | "metadata": {},
101 | "source": [
102 | "The total number of elements in the array is given by the attribute **size**."
103 | ]
104 | },
105 | {
106 | "cell_type": "code",
107 | "execution_count": null,
108 | "metadata": {
109 | "collapsed": false
110 | },
111 | "outputs": [],
112 | "source": [
113 | "A.size"
114 | ]
115 | },
116 | {
117 | "cell_type": "markdown",
118 | "metadata": {},
119 | "source": [
120 | "### Accessing different elements of an Numpy Array "
121 | ]
122 | },
123 | {
124 | "cell_type": "markdown",
125 | "metadata": {},
126 | "source": [
127 | " We can use rectangular brackets to access the different elements of the array,The correspondence between the rectangular brackets and the list and the rectangular representation is shown in the following figure for a 3x3 array: "
128 | ]
129 | },
130 | {
131 | "cell_type": "markdown",
132 | "metadata": {},
133 | "source": [
134 | "![](\"http://akhavanpour.ir/notebook/python-labs/numpy-4.png\")
\n"
135 | ]
136 | },
137 | {
138 | "cell_type": "markdown",
139 | "metadata": {},
140 | "source": [
141 | "We can access the 2nd-row 3rd column as shown in the following figure:"
142 | ]
143 | },
144 | {
145 | "cell_type": "markdown",
146 | "metadata": {},
147 | "source": [
148 | "![](\"http://akhavanpour.ir/notebook/python-labs/numpy-5.png\")
\n"
149 | ]
150 | },
151 | {
152 | "cell_type": "markdown",
153 | "metadata": {},
154 | "source": [
155 | " We simply use the square brackets and the indices corresponding to the element we would like:"
156 | ]
157 | },
158 | {
159 | "cell_type": "code",
160 | "execution_count": null,
161 | "metadata": {
162 | "collapsed": false
163 | },
164 | "outputs": [],
165 | "source": [
166 | "A[1,2]"
167 | ]
168 | },
169 | {
170 | "cell_type": "markdown",
171 | "metadata": {},
172 | "source": [
173 | " We can also use the following notation to obtain the elements: "
174 | ]
175 | },
176 | {
177 | "cell_type": "code",
178 | "execution_count": null,
179 | "metadata": {
180 | "collapsed": false
181 | },
182 | "outputs": [],
183 | "source": [
184 | "A[1][2]"
185 | ]
186 | },
187 | {
188 | "cell_type": "markdown",
189 | "metadata": {},
190 | "source": [
191 | " Consider the elements shown in the following figure "
192 | ]
193 | },
194 | {
195 | "cell_type": "markdown",
196 | "metadata": {},
197 | "source": [
198 | "![](\"http://akhavanpour.ir/notebook/python-labs/numpy-6.png\")
\n"
199 | ]
200 | },
201 | {
202 | "cell_type": "markdown",
203 | "metadata": {},
204 | "source": [
205 | " we can access the element as follows "
206 | ]
207 | },
208 | {
209 | "cell_type": "code",
210 | "execution_count": null,
211 | "metadata": {
212 | "collapsed": false
213 | },
214 | "outputs": [],
215 | "source": [
216 | "A[0][0]"
217 | ]
218 | },
219 | {
220 | "cell_type": "markdown",
221 | "metadata": {},
222 | "source": [
223 | " We can also use slicing in numpy arrays,consider the following figure; we would like to obtain the first two columns in the first row "
224 | ]
225 | },
226 | {
227 | "cell_type": "markdown",
228 | "metadata": {},
229 | "source": [
230 | "![](\"http://akhavanpour.ir/notebook/python-labs/numpy-7.png\")
\n"
231 | ]
232 | },
233 | {
234 | "cell_type": "markdown",
235 | "metadata": {},
236 | "source": [
237 | " This can be done with the following syntax "
238 | ]
239 | },
240 | {
241 | "cell_type": "code",
242 | "execution_count": null,
243 | "metadata": {
244 | "collapsed": false
245 | },
246 | "outputs": [],
247 | "source": [
248 | " A[0][0:2]"
249 | ]
250 | },
251 | {
252 | "cell_type": "markdown",
253 | "metadata": {},
254 | "source": [
255 | "Similarly, we can obtain the first two rows of the 3rd column as follows:"
256 | ]
257 | },
258 | {
259 | "cell_type": "code",
260 | "execution_count": null,
261 | "metadata": {
262 | "collapsed": false
263 | },
264 | "outputs": [],
265 | "source": [
266 | "A[1:3,2]"
267 | ]
268 | },
269 | {
270 | "cell_type": "markdown",
271 | "metadata": {
272 | "collapsed": false
273 | },
274 | "source": [
275 | "Corresponding to the following figure: "
276 | ]
277 | },
278 | {
279 | "cell_type": "markdown",
280 | "metadata": {},
281 | "source": [
282 | "![](\"http://akhavanpour.ir/notebook/python-labs/numpy-8.png\")
\n"
283 | ]
284 | },
285 | {
286 | "cell_type": "markdown",
287 | "metadata": {},
288 | "source": [
289 | "# Basic Operations "
290 | ]
291 | },
292 | {
293 | "cell_type": "markdown",
294 | "metadata": {},
295 | "source": [
296 | " We can also add arrays; the process is identical to matrix addition. Matrix addition of **X** and **Y** is shown in the following figure:"
297 | ]
298 | },
299 | {
300 | "cell_type": "markdown",
301 | "metadata": {},
302 | "source": [
303 | "![](\"http://akhavanpour.ir/notebook/python-labs/numpy-9.png\")
\n"
304 | ]
305 | },
306 | {
307 | "cell_type": "markdown",
308 | "metadata": {},
309 | "source": [
310 | " The numpy array is given by **X** and **Y**"
311 | ]
312 | },
313 | {
314 | "cell_type": "code",
315 | "execution_count": null,
316 | "metadata": {
317 | "collapsed": false
318 | },
319 | "outputs": [],
320 | "source": [
321 | "X=np.array([[1,0],[0,1]]) \n",
322 | "X"
323 | ]
324 | },
325 | {
326 | "cell_type": "code",
327 | "execution_count": null,
328 | "metadata": {
329 | "collapsed": false
330 | },
331 | "outputs": [],
332 | "source": [
333 | "Y=np.array([[2,1],[1,2]]) \n",
334 | "Y"
335 | ]
336 | },
337 | {
338 | "cell_type": "markdown",
339 | "metadata": {},
340 | "source": [
341 | " We can add the numpy arrays as follows."
342 | ]
343 | },
344 | {
345 | "cell_type": "code",
346 | "execution_count": null,
347 | "metadata": {
348 | "collapsed": false
349 | },
350 | "outputs": [],
351 | "source": [
352 | "Z=X+Y\n",
353 | "Z"
354 | ]
355 | },
356 | {
357 | "cell_type": "markdown",
358 | "metadata": {},
359 | "source": [
360 | " Multiplying a numpy array by a scaler is identical to multiplying a matrix by a scaler. If we multiply the matrix **Y** by the scaler 2, we simply multiply every element in the matrix by 2 as shown in the figure."
361 | ]
362 | },
363 | {
364 | "cell_type": "markdown",
365 | "metadata": {},
366 | "source": [
367 | "![](\"http://akhavanpour.ir/notebook/python-labs/numpy-10.png\")
\n"
368 | ]
369 | },
370 | {
371 | "cell_type": "markdown",
372 | "metadata": {},
373 | "source": [
374 | " We can perform the same operation in numpy as follows "
375 | ]
376 | },
377 | {
378 | "cell_type": "code",
379 | "execution_count": null,
380 | "metadata": {
381 | "collapsed": false
382 | },
383 | "outputs": [],
384 | "source": [
385 | "Y=np.array([[2,1],[1,2]]) \n",
386 | "Y"
387 | ]
388 | },
389 | {
390 | "cell_type": "code",
391 | "execution_count": null,
392 | "metadata": {
393 | "collapsed": false
394 | },
395 | "outputs": [],
396 | "source": [
397 | "Z=2*Y\n",
398 | "Z"
399 | ]
400 | },
401 | {
402 | "cell_type": "markdown",
403 | "metadata": {},
404 | "source": [
405 | " Multiplication of two arrays corresponds to an element-wise product or Hadamard product. Consider matrix **X** and **Y**. The Hadamard product corresponds to multiplying each of the elements in the same position, i.e. multiplying elements contained in the same colour boxes together. The result is a new matrix that is the same size as matrix **Y** or **X**, as shown in the following figure."
406 | ]
407 | },
408 | {
409 | "cell_type": "markdown",
410 | "metadata": {},
411 | "source": [
412 | "![](\"http://akhavanpour.ir/notebook/python-labs/numpy-11.png\")
\n"
413 | ]
414 | },
415 | {
416 | "cell_type": "markdown",
417 | "metadata": {},
418 | "source": [
419 | "We can perform element-wise product of the array **X** and **Y** as follows:"
420 | ]
421 | },
422 | {
423 | "cell_type": "code",
424 | "execution_count": null,
425 | "metadata": {
426 | "collapsed": false
427 | },
428 | "outputs": [],
429 | "source": [
430 | "Y=np.array([[2,1],[1,2]]) \n",
431 | "Y"
432 | ]
433 | },
434 | {
435 | "cell_type": "code",
436 | "execution_count": null,
437 | "metadata": {
438 | "collapsed": false
439 | },
440 | "outputs": [],
441 | "source": [
442 | "X=np.array([[1,0],[0,1]]) \n",
443 | "X"
444 | ]
445 | },
446 | {
447 | "cell_type": "code",
448 | "execution_count": null,
449 | "metadata": {
450 | "collapsed": false
451 | },
452 | "outputs": [],
453 | "source": [
454 | "Z=X*Y\n",
455 | "Z"
456 | ]
457 | },
458 | {
459 | "cell_type": "markdown",
460 | "metadata": {},
461 | "source": [
462 | " We can also perform matrix multiplication with the numpy arrays **A** and **B** as follows:"
463 | ]
464 | },
465 | {
466 | "cell_type": "markdown",
467 | "metadata": {},
468 | "source": [
469 | " First, we define matrix **A** and **B**:"
470 | ]
471 | },
472 | {
473 | "cell_type": "code",
474 | "execution_count": null,
475 | "metadata": {
476 | "collapsed": false
477 | },
478 | "outputs": [],
479 | "source": [
480 | "A=np.array([[0,1,1],[1,0,1]])\n",
481 | "A"
482 | ]
483 | },
484 | {
485 | "cell_type": "code",
486 | "execution_count": null,
487 | "metadata": {
488 | "collapsed": false
489 | },
490 | "outputs": [],
491 | "source": [
492 | "B=np.array([[1,1],[1,1],[-1,1]])\n",
493 | "B"
494 | ]
495 | },
496 | {
497 | "cell_type": "markdown",
498 | "metadata": {},
499 | "source": [
500 | "We use the numpy function **dot** to multiply the arrays together."
501 | ]
502 | },
503 | {
504 | "cell_type": "code",
505 | "execution_count": null,
506 | "metadata": {
507 | "collapsed": false
508 | },
509 | "outputs": [],
510 | "source": [
511 | "Z=np.dot(A,B)\n",
512 | "Z"
513 | ]
514 | },
515 | {
516 | "cell_type": "code",
517 | "execution_count": null,
518 | "metadata": {
519 | "collapsed": false
520 | },
521 | "outputs": [],
522 | "source": [
523 | "np.sin(Z)"
524 | ]
525 | },
526 | {
527 | "cell_type": "code",
528 | "execution_count": null,
529 | "metadata": {
530 | "collapsed": false
531 | },
532 | "outputs": [],
533 | "source": [
534 | "C=np.array([[1,1],[2,2],[3,3]])\n",
535 | "C"
536 | ]
537 | },
538 | {
539 | "cell_type": "code",
540 | "execution_count": null,
541 | "metadata": {
542 | "collapsed": false
543 | },
544 | "outputs": [],
545 | "source": [
546 | "C.T"
547 | ]
548 | },
549 | {
550 | "cell_type": "markdown",
551 | "metadata": {
552 | "collapsed": true
553 | },
554 | "source": [
555 | "#### About the Authors: \n",
556 | "\n",
557 | " [Joseph Santarcangelo]( https://www.linkedin.com/in/joseph-s-50398b136/) has a PhD in Electrical Engineering, his research focused on using machine learning, signal processing, and computer vision to determine how videos impact human cognition. Joseph has been working for IBM since he completed his PhD."
558 | ]
559 | },
560 | {
561 | "cell_type": "markdown",
562 | "metadata": {},
563 | "source": [
564 | "Copyright © 2017 [cognitiveclass.ai](cognitiveclass.ai?utm_source=bducopyrightlink&utm_medium=dswb&utm_campaign=bdu). This notebook and its source code are released under the terms of the [MIT License](https://bigdatauniversity.com/mit-license/)."
565 | ]
566 | },
567 | {
568 | "cell_type": "code",
569 | "execution_count": null,
570 | "metadata": {
571 | "collapsed": true
572 | },
573 | "outputs": [],
574 | "source": []
575 | }
576 | ],
577 | "metadata": {
578 | "anaconda-cloud": {},
579 | "kernelspec": {
580 | "display_name": "Python [default]",
581 | "language": "python",
582 | "name": "python3"
583 | },
584 | "language_info": {
585 | "codemirror_mode": {
586 | "name": "ipython",
587 | "version": 3
588 | },
589 | "file_extension": ".py",
590 | "mimetype": "text/x-python",
591 | "name": "python",
592 | "nbconvert_exporter": "python",
593 | "pygments_lexer": "ipython3",
594 | "version": "3.5.2"
595 | }
596 | },
597 | "nbformat": 4,
598 | "nbformat_minor": 2
599 | }
600 |
--------------------------------------------------------------------------------
/5-1_Dictionaries_v5.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | ""
8 | ]
9 | },
10 | {
11 | "cell_type": "markdown",
12 | "metadata": {},
13 | "source": [
14 | "\n",
15 | "## Table of Contents\n",
16 | "\n",
17 | "\n",
18 | "![](\"https://ibm.box.com/shared/static/6tyznuwydogmtuv73o8l5g7xsb8o92h2.png\")
\n",
49 | " ![](\"https://ibm.box.com/shared/static/i45fppou18c3t0fuf2ikks48tod7chbl.png\")
\n",
149 | " ![](\"https://ibm.box.com/shared/static/glbwz23cgjjxqi7rjxn7me5i16gan7h7.png\")
\n",
256 | " ![](\"https://ibm.box.com/shared/static/6t7bu8jusckaskukwq1k0a3im5ltcpsn.png)
\n",
285 | " "
8 | ]
9 | },
10 | {
11 | "cell_type": "markdown",
12 | "metadata": {},
13 | "source": [
14 | "## Table of content\n",
15 | "\n",
16 | "You can select the columns of a data frame by indicating the name of each column, for example, you can select the three columns as follows:
\n", 359 | "\n", 360 | "dataframe[[' column 1 ',column 2', 'column 3'] ]
\n", 361 | "\n", 362 | "where \"column\" is the name of the column, you can apply the method \".describe()\" to get the statistics of those columns as follows:
\n", 363 | "\n", 364 | "dataframe[[' column 1 ',column 2', 'column 3'] ].describe()
\n", 365 | "\n", 366 | "\n", 367 | "Apply the method to \".describe()\" to the columns 'length' and 'compression-ratio'.\n", 368 | ""
8 | ]
9 | },
10 | {
11 | "cell_type": "markdown",
12 | "metadata": {},
13 | "source": [
14 | "# "
8 | ]
9 | },
10 | {
11 | "cell_type": "markdown",
12 | "metadata": {},
13 | "source": [
14 | "## Table of content\n",
15 | "\n",
16 | ".replace(A, B, inplace = True)\n", 194 | "to replace A by B" 195 | ] 196 | }, 197 | { 198 | "cell_type": "code", 199 | "execution_count": null, 200 | "metadata": { 201 | "collapsed": false 202 | }, 203 | "outputs": [], 204 | "source": [ 205 | "import numpy as np\n", 206 | "\n", 207 | "# replace \"?\" to NaN\n", 208 | "df.replace(\"?\", np.nan, inplace = True)\n", 209 | "df.head(5)" 210 | ] 211 | }, 212 | { 213 | "cell_type": "markdown", 214 | "metadata": {}, 215 | "source": [ 216 | "### Evaluating for Missing Data\n", 217 | "\n", 218 | "The missing values are converted to Python's default. We use Python's built-in functions to identify these missing values. There are two methods to detect missing data:\n", 219 | "1. **.isnull()**\n", 220 | "2. **.notnull()**\n", 221 | "\n", 222 | "The output is a boolean value indicating whether the passed in argument value are in fact missing data." 223 | ] 224 | }, 225 | { 226 | "cell_type": "code", 227 | "execution_count": null, 228 | "metadata": { 229 | "collapsed": false 230 | }, 231 | "outputs": [], 232 | "source": [ 233 | "missing_data = df.isnull()\n", 234 | "missing_data.head(5)" 235 | ] 236 | }, 237 | { 238 | "cell_type": "markdown", 239 | "metadata": {}, 240 | "source": [ 241 | "\"True\" stands for missing value, while \"False\" stands for not missing value." 242 | ] 243 | }, 244 | { 245 | "cell_type": "markdown", 246 | "metadata": {}, 247 | "source": [ 248 | "### Count missing values in each column\n", 249 | "Using a for loop in Python, we can quickly figure out the number of missing values in each column. As mentioned above, \"True\" represents a missing value, \"False\" means the value is present in the dataset. In the body of the for loop the method \".value_couts()\" counts the number of \"True\" values. " 250 | ] 251 | }, 252 | { 253 | "cell_type": "code", 254 | "execution_count": null, 255 | "metadata": { 256 | "collapsed": false 257 | }, 258 | "outputs": [], 259 | "source": [ 260 | "for column in missing_data.columns.values.tolist():\n", 261 | " print(column)\n", 262 | " print (missing_data[column].value_counts())\n", 263 | " print(\"\") " 264 | ] 265 | }, 266 | { 267 | "cell_type": "markdown", 268 | "metadata": {}, 269 | "source": [ 270 | "Based on the summary above, each column has 205 rows of data, seven columns containing missing data:\n", 271 | "\n", 272 | "1. \"normalized-losses\": 41 missing data\n", 273 | "2. \"num-of-doors\": 2 missing data\n", 274 | "3. \"bore\": 4 missing data\n", 275 | "4. \"stroke\" : 4 missing data\n", 276 | "5. \"horsepower\": 2 missing data\n", 277 | "6. \"peak-rpm\": 2 missing data\n", 278 | "7. \"price\": 4 missing data" 279 | ] 280 | }, 281 | { 282 | "cell_type": "markdown", 283 | "metadata": {}, 284 | "source": [ 285 | "\n", 286 | "## Deal with missing data\n", 287 | "**How to deal with missing data?**\n", 288 | "\n", 289 | " \n", 290 | " 1. drop data \n", 291 | " a. drop the whole row\n", 292 | " b. drop the whole column\n", 293 | " 2. replace data\n", 294 | " a. replace it by mean\n", 295 | " b. replace it by frequency\n", 296 | " c. replace it based on other functions" 297 | ] 298 | }, 299 | { 300 | "cell_type": "markdown", 301 | "metadata": {}, 302 | "source": [ 303 | "Whole columns should be dropped only if most entries in the column are empty. In our dataset, none of the columns are empty enough to drop entirely.\n", 304 | "We have some freedom in choosing which method to replace data; however, some methods may seem more reasonable than others. We will apply each method to many different columns:\n", 305 | "\n", 306 | "**Replace by mean:**\n", 307 | "\n", 308 | " \"normalized-losses\": 41 missing data, replace them with mean\n", 309 | " \"stroke\": 4 missing data, replace them with mean\n", 310 | " \"bore\": 4 missing data, replace them with mean\n", 311 | " \"horsepower\": 2 missing data, replace them with mean\n", 312 | " \"peak-rpm\": 2 missing data, replace them with mean\n", 313 | " \n", 314 | "**Replace by frequency:**\n", 315 | "\n", 316 | " \"num-of-doors\": 2 missing data, replace them with \"four\". \n", 317 | " * Reason: 84% sedans is four doors. Since four doors is most frequent, it is most likely to \n", 318 | " \n", 319 | "\n", 320 | "**Drop the whole row:**\n", 321 | "\n", 322 | " \"price\": 4 missing data, simply delete the whole row\n", 323 | " * Reason: price is what we want to predict. Any data entry without price data cannot be used for prediction; therefore they are not useful to us" 324 | ] 325 | }, 326 | { 327 | "cell_type": "markdown", 328 | "metadata": {}, 329 | "source": [ 330 | "#### Calculate the average of the column " 331 | ] 332 | }, 333 | { 334 | "cell_type": "code", 335 | "execution_count": null, 336 | "metadata": { 337 | "collapsed": false 338 | }, 339 | "outputs": [], 340 | "source": [ 341 | "avg_1 = df[\"normalized-losses\"].astype(\"float\").mean(axis = 0)" 342 | ] 343 | }, 344 | { 345 | "cell_type": "markdown", 346 | "metadata": {}, 347 | "source": [ 348 | "#### Replace \"NaN\" by mean value in \"normalized-losses\" column" 349 | ] 350 | }, 351 | { 352 | "cell_type": "code", 353 | "execution_count": null, 354 | "metadata": { 355 | "collapsed": true 356 | }, 357 | "outputs": [], 358 | "source": [ 359 | "df[\"normalized-losses\"].replace(np.nan, avg_1, inplace = True)" 360 | ] 361 | }, 362 | { 363 | "cell_type": "markdown", 364 | "metadata": {}, 365 | "source": [ 366 | "#### Calculate the mean value for 'bore' column" 367 | ] 368 | }, 369 | { 370 | "cell_type": "code", 371 | "execution_count": null, 372 | "metadata": { 373 | "collapsed": true 374 | }, 375 | "outputs": [], 376 | "source": [ 377 | "avg_2=df['bore'].astype('float').mean(axis=0)" 378 | ] 379 | }, 380 | { 381 | "cell_type": "markdown", 382 | "metadata": {}, 383 | "source": [ 384 | "#### Replace NaN by mean value" 385 | ] 386 | }, 387 | { 388 | "cell_type": "code", 389 | "execution_count": null, 390 | "metadata": { 391 | "collapsed": true 392 | }, 393 | "outputs": [], 394 | "source": [ 395 | "df['bore'].replace(np.nan, avg_2, inplace= True)" 396 | ] 397 | }, 398 | { 399 | "cell_type": "markdown", 400 | "metadata": {}, 401 | "source": [ 402 | "
"
8 | ]
9 | },
10 | {
11 | "cell_type": "markdown",
12 | "metadata": {},
13 | "source": [
14 | "# ![\"Data](\"http://akhavanpour.ir/notebook/python-labs/type.png\")
"
137 | ]
138 | },
139 | {
140 | "cell_type": "code",
141 | "execution_count": null,
142 | "metadata": {
143 | "collapsed": false
144 | },
145 | "outputs": [],
146 | "source": [
147 | "81 #integer"
148 | ]
149 | },
150 | {
151 | "cell_type": "code",
152 | "execution_count": null,
153 | "metadata": {
154 | "collapsed": false
155 | },
156 | "outputs": [],
157 | "source": [
158 | "5.9 #float"
159 | ]
160 | },
161 | {
162 | "cell_type": "code",
163 | "execution_count": null,
164 | "metadata": {
165 | "collapsed": false
166 | },
167 | "outputs": [],
168 | "source": [
169 | "\"Hello Python\" #character string"
170 | ]
171 | },
172 | {
173 | "cell_type": "markdown",
174 | "metadata": {},
175 | "source": [
176 | ""
8 | ]
9 | },
10 | {
11 | "cell_type": "markdown",
12 | "metadata": {},
13 | "source": [
14 | "![\"string](\"http://akhavanpour.ir/notebook/python-labs/string-index.png\")
"
254 | ]
255 | },
256 | {
257 | "cell_type": "markdown",
258 | "metadata": {},
259 | "source": [
260 | "![\"negative](\"http://akhavanpour.ir/notebook/python-labs/string-negative-index.png\")
"
334 | ]
335 | },
336 | {
337 | "cell_type": "markdown",
338 | "metadata": {},
339 | "source": [
340 | "![\"stride](\"http://akhavanpour.ir/notebook/python-labs/string-stride-index.png\")
"
558 | ]
559 | },
560 | {
561 | "cell_type": "code",
562 | "execution_count": 18,
563 | "metadata": {
564 | "collapsed": false
565 | },
566 | "outputs": [
567 | {
568 | "data": {
569 | "text/plain": [
570 | "'STU'"
571 | ]
572 | },
573 | "execution_count": 18,
574 | "metadata": {},
575 | "output_type": "execute_result"
576 | }
577 | ],
578 | "source": [
579 | "Name[::2]"
580 | ]
581 | },
582 | {
583 | "cell_type": "code",
584 | "execution_count": 19,
585 | "metadata": {
586 | "collapsed": false
587 | },
588 | "outputs": [
589 | {
590 | "data": {
591 | "text/plain": [
592 | "'ST'"
593 | ]
594 | },
595 | "execution_count": 19,
596 | "metadata": {},
597 | "output_type": "execute_result"
598 | }
599 | ],
600 | "source": [
601 | "Name[0:3:2]"
602 | ]
603 | },
604 | {
605 | "cell_type": "markdown",
606 | "metadata": {},
607 | "source": [
608 | ""
8 | ]
9 | },
10 | {
11 | "cell_type": "code",
12 | "execution_count": null,
13 | "metadata": {
14 | "collapsed": true
15 | },
16 | "outputs": [],
17 | "source": [
18 | "import time \n",
19 | "import sys\n",
20 | "import numpy as np \n",
21 | "\n",
22 | "import matplotlib.pyplot as plt\n",
23 | "%matplotlib inline "
24 | ]
25 | },
26 | {
27 | "cell_type": "markdown",
28 | "metadata": {},
29 | "source": [
30 | "![](\"http://akhavanpour.ir/notebook/python-labs/numpy-1.png\")
"
102 | ]
103 | },
104 | {
105 | "cell_type": "markdown",
106 | "metadata": {},
107 | "source": [
108 | "We can access each element using a square bracket as follows: "
109 | ]
110 | },
111 | {
112 | "cell_type": "code",
113 | "execution_count": null,
114 | "metadata": {
115 | "collapsed": false
116 | },
117 | "outputs": [],
118 | "source": [
119 | "print(\"a[0]:\",a[0])\n",
120 | "print(\"a[1]:\",a[1])\n",
121 | "print(\"a[2]:\",a[2])\n",
122 | "print(\"a[3]:\",a[3])\n",
123 | "print(\"a[4]:\",a[4])"
124 | ]
125 | },
126 | {
127 | "cell_type": "markdown",
128 | "metadata": {},
129 | "source": [
130 | "A numpy array is similar to a list, it's usually fixed in size and each element is of the same type. We can cast a list to a numpy array by first importing numpy: "
131 | ]
132 | },
133 | {
134 | "cell_type": "code",
135 | "execution_count": null,
136 | "metadata": {
137 | "collapsed": false
138 | },
139 | "outputs": [],
140 | "source": [
141 | "import numpy as np "
142 | ]
143 | },
144 | {
145 | "cell_type": "markdown",
146 | "metadata": {},
147 | "source": [
148 | " We then cast the list as follows:"
149 | ]
150 | },
151 | {
152 | "cell_type": "code",
153 | "execution_count": null,
154 | "metadata": {
155 | "collapsed": false
156 | },
157 | "outputs": [],
158 | "source": [
159 | "a=np.array([0,1,2,3, 4])\n",
160 | "a"
161 | ]
162 | },
163 | {
164 | "cell_type": "markdown",
165 | "metadata": {},
166 | "source": [
167 | "Each element is of the same type, in this case integers: "
168 | ]
169 | },
170 | {
171 | "cell_type": "markdown",
172 | "metadata": {},
173 | "source": [
174 | "![](\"http://akhavanpour.ir/notebook/python-labs/numpy-2.png\")
"
175 | ]
176 | },
177 | {
178 | "cell_type": "markdown",
179 | "metadata": {},
180 | "source": [
181 | " As with lists, we can access each element via a square bracket:"
182 | ]
183 | },
184 | {
185 | "cell_type": "code",
186 | "execution_count": null,
187 | "metadata": {
188 | "collapsed": false
189 | },
190 | "outputs": [],
191 | "source": [
192 | "print(\"a[0]:\",a[0])\n",
193 | "print(\"a[1]:\",a[1])\n",
194 | "print(\"a[2]:\",a[2])\n",
195 | "print(\"a[3]:\",a[3])\n",
196 | "print(\"a[4]:\",a[4])"
197 | ]
198 | },
199 | {
200 | "cell_type": "markdown",
201 | "metadata": {},
202 | "source": [
203 | "The value of “a” is stored a follows: "
204 | ]
205 | },
206 | {
207 | "cell_type": "code",
208 | "execution_count": null,
209 | "metadata": {
210 | "collapsed": false
211 | },
212 | "outputs": [],
213 | "source": [
214 | "a"
215 | ]
216 | },
217 | {
218 | "cell_type": "markdown",
219 | "metadata": {},
220 | "source": [
221 | "If we check the type of the array we get \"numpy.ndarray\":"
222 | ]
223 | },
224 | {
225 | "cell_type": "code",
226 | "execution_count": null,
227 | "metadata": {
228 | "collapsed": false
229 | },
230 | "outputs": [],
231 | "source": [
232 | "type(a)"
233 | ]
234 | },
235 | {
236 | "cell_type": "markdown",
237 | "metadata": {},
238 | "source": [
239 | "As numpy arrays contain data of the same type, we can use the attribute \"dtype\" to obtain the Data-type of the array’s elements. In this case a 64-bit integer: \n"
240 | ]
241 | },
242 | {
243 | "cell_type": "code",
244 | "execution_count": null,
245 | "metadata": {
246 | "collapsed": false
247 | },
248 | "outputs": [],
249 | "source": [
250 | "a.dtype"
251 | ]
252 | },
253 | {
254 | "cell_type": "markdown",
255 | "metadata": {},
256 | "source": [
257 | "We can create a numpy array with real numbers:"
258 | ]
259 | },
260 | {
261 | "cell_type": "code",
262 | "execution_count": null,
263 | "metadata": {
264 | "collapsed": false
265 | },
266 | "outputs": [],
267 | "source": [
268 | "b=np.array([3.1,11.02,6.2, 213.2,5.2])"
269 | ]
270 | },
271 | {
272 | "cell_type": "markdown",
273 | "metadata": {},
274 | "source": [
275 | "When we check the type of the array we get \"numpy.ndarray\":"
276 | ]
277 | },
278 | {
279 | "cell_type": "code",
280 | "execution_count": null,
281 | "metadata": {
282 | "collapsed": false
283 | },
284 | "outputs": [],
285 | "source": [
286 | "type(b)"
287 | ]
288 | },
289 | {
290 | "cell_type": "markdown",
291 | "metadata": {},
292 | "source": [
293 | "If we examine the attribute \"dtype\" we see float 64, as the elements are not integers: "
294 | ]
295 | },
296 | {
297 | "cell_type": "code",
298 | "execution_count": null,
299 | "metadata": {
300 | "collapsed": false
301 | },
302 | "outputs": [],
303 | "source": [
304 | "b.dtype"
305 | ]
306 | },
307 | {
308 | "cell_type": "markdown",
309 | "metadata": {},
310 | "source": [
311 | "We can change the value of the array, consider the array \"c\":"
312 | ]
313 | },
314 | {
315 | "cell_type": "code",
316 | "execution_count": null,
317 | "metadata": {
318 | "collapsed": false
319 | },
320 | "outputs": [],
321 | "source": [
322 | "c=np.array([20,1,2,3,4])\n",
323 | "c"
324 | ]
325 | },
326 | {
327 | "cell_type": "markdown",
328 | "metadata": {},
329 | "source": [
330 | "We can change the first element of the array to 100 as follows:"
331 | ]
332 | },
333 | {
334 | "cell_type": "code",
335 | "execution_count": null,
336 | "metadata": {
337 | "collapsed": false
338 | },
339 | "outputs": [],
340 | "source": [
341 | "c[0]=100\n",
342 | "c"
343 | ]
344 | },
345 | {
346 | "cell_type": "markdown",
347 | "metadata": {},
348 | "source": [
349 | "We can change the 5th element of the array as follows:"
350 | ]
351 | },
352 | {
353 | "cell_type": "code",
354 | "execution_count": null,
355 | "metadata": {
356 | "collapsed": false
357 | },
358 | "outputs": [],
359 | "source": [
360 | "c[4]=0\n",
361 | "c"
362 | ]
363 | },
364 | {
365 | "cell_type": "markdown",
366 | "metadata": {},
367 | "source": [
368 | "\n",
369 | "Like lists, we can slice the numpy array, and we can select the elements from 1 to 3 and assign it to a new numpy array 'd' as follows:\n"
370 | ]
371 | },
372 | {
373 | "cell_type": "code",
374 | "execution_count": null,
375 | "metadata": {
376 | "collapsed": false
377 | },
378 | "outputs": [],
379 | "source": [
380 | "d=c[1:4]\n",
381 | "d"
382 | ]
383 | },
384 | {
385 | "cell_type": "markdown",
386 | "metadata": {},
387 | "source": [
388 | "We can assign the corresponding indexes to new values as follows: "
389 | ]
390 | },
391 | {
392 | "cell_type": "code",
393 | "execution_count": null,
394 | "metadata": {
395 | "collapsed": false
396 | },
397 | "outputs": [],
398 | "source": [
399 | "c[3:5]=300,400\n",
400 | "c"
401 | ]
402 | },
403 | {
404 | "cell_type": "markdown",
405 | "metadata": {},
406 | "source": [
407 | "Similarly, we can use a list to select a specific index.\n",
408 | "The list ' select ' contains several values:\n"
409 | ]
410 | },
411 | {
412 | "cell_type": "code",
413 | "execution_count": null,
414 | "metadata": {
415 | "collapsed": true
416 | },
417 | "outputs": [],
418 | "source": [
419 | "select=[0,2,3]"
420 | ]
421 | },
422 | {
423 | "cell_type": "markdown",
424 | "metadata": {},
425 | "source": [
426 | "We can use the list as an argument in the brackets. The output is the elements corresponding to the particular index:"
427 | ]
428 | },
429 | {
430 | "cell_type": "code",
431 | "execution_count": null,
432 | "metadata": {
433 | "collapsed": false
434 | },
435 | "outputs": [],
436 | "source": [
437 | "d=c[select]\n",
438 | "d"
439 | ]
440 | },
441 | {
442 | "cell_type": "markdown",
443 | "metadata": {},
444 | "source": [
445 | "We can assign the specified elements to a new value. For example, we can assign the values to 100 000 as follows:"
446 | ]
447 | },
448 | {
449 | "cell_type": "code",
450 | "execution_count": null,
451 | "metadata": {
452 | "collapsed": false
453 | },
454 | "outputs": [],
455 | "source": [
456 | "c[select]=100000\n",
457 | "c"
458 | ]
459 | },
460 | {
461 | "cell_type": "markdown",
462 | "metadata": {},
463 | "source": [
464 | "Let's review some basic array attributes using the array ‘a’:"
465 | ]
466 | },
467 | {
468 | "cell_type": "code",
469 | "execution_count": null,
470 | "metadata": {
471 | "collapsed": false
472 | },
473 | "outputs": [],
474 | "source": [
475 | "a=np.array([0,1,2,3, 4])\n",
476 | "a"
477 | ]
478 | },
479 | {
480 | "cell_type": "markdown",
481 | "metadata": {},
482 | "source": [
483 | "The attribute size is the Number of elements in the array:"
484 | ]
485 | },
486 | {
487 | "cell_type": "code",
488 | "execution_count": null,
489 | "metadata": {
490 | "collapsed": false
491 | },
492 | "outputs": [],
493 | "source": [
494 | "a.size"
495 | ]
496 | },
497 | {
498 | "cell_type": "markdown",
499 | "metadata": {},
500 | "source": [
501 | "The next two attributes will make more sense when we get to higher dimensions but let's review them. The attribute “ndim” represents the Number of array dimensions or the rank of the array, in this case, one:"
502 | ]
503 | },
504 | {
505 | "cell_type": "code",
506 | "execution_count": null,
507 | "metadata": {
508 | "collapsed": false
509 | },
510 | "outputs": [],
511 | "source": [
512 | "a.ndim"
513 | ]
514 | },
515 | {
516 | "cell_type": "markdown",
517 | "metadata": {},
518 | "source": [
519 | "The attribute “shape” is a tuple of integers indicating the size of the array in each dimension:"
520 | ]
521 | },
522 | {
523 | "cell_type": "code",
524 | "execution_count": null,
525 | "metadata": {
526 | "collapsed": false
527 | },
528 | "outputs": [],
529 | "source": [
530 | "a.shape"
531 | ]
532 | },
533 | {
534 | "cell_type": "code",
535 | "execution_count": null,
536 | "metadata": {
537 | "collapsed": true
538 | },
539 | "outputs": [],
540 | "source": [
541 | "a=np.array([1,-1,1,-1])"
542 | ]
543 | },
544 | {
545 | "cell_type": "code",
546 | "execution_count": null,
547 | "metadata": {
548 | "collapsed": false
549 | },
550 | "outputs": [],
551 | "source": [
552 | "mean=a.mean()\n",
553 | "mean"
554 | ]
555 | },
556 | {
557 | "cell_type": "code",
558 | "execution_count": null,
559 | "metadata": {
560 | "collapsed": false
561 | },
562 | "outputs": [],
563 | "source": [
564 | "standard_deviation=a.std()\n",
565 | "standard_deviation"
566 | ]
567 | },
568 | {
569 | "cell_type": "code",
570 | "execution_count": null,
571 | "metadata": {
572 | "collapsed": false
573 | },
574 | "outputs": [],
575 | "source": [
576 | "b=np.array([1,2,3,4,5])\n",
577 | "b"
578 | ]
579 | },
580 | {
581 | "cell_type": "code",
582 | "execution_count": null,
583 | "metadata": {
584 | "collapsed": false
585 | },
586 | "outputs": [],
587 | "source": [
588 | "max_b=b.max()"
589 | ]
590 | },
591 | {
592 | "cell_type": "code",
593 | "execution_count": null,
594 | "metadata": {
595 | "collapsed": false
596 | },
597 | "outputs": [],
598 | "source": [
599 | "max_b=b.min()"
600 | ]
601 | },
602 | {
603 | "cell_type": "markdown",
604 | "metadata": {},
605 | "source": [
606 | "## Array Addition "
607 | ]
608 | },
609 | {
610 | "cell_type": "markdown",
611 | "metadata": {},
612 | "source": [
613 | "Consider the numpy array 'u':"
614 | ]
615 | },
616 | {
617 | "cell_type": "code",
618 | "execution_count": null,
619 | "metadata": {
620 | "collapsed": false
621 | },
622 | "outputs": [],
623 | "source": [
624 | "u=np.array([1,0])\n",
625 | "u"
626 | ]
627 | },
628 | {
629 | "cell_type": "markdown",
630 | "metadata": {},
631 | "source": [
632 | "Consider the numpy array 'v':"
633 | ]
634 | },
635 | {
636 | "cell_type": "code",
637 | "execution_count": null,
638 | "metadata": {
639 | "collapsed": false
640 | },
641 | "outputs": [],
642 | "source": [
643 | "v=np.array([0,1])\n",
644 | "v"
645 | ]
646 | },
647 | {
648 | "cell_type": "markdown",
649 | "metadata": {},
650 | "source": [
651 | "We can add the two arrays and assign it to z:"
652 | ]
653 | },
654 | {
655 | "cell_type": "code",
656 | "execution_count": null,
657 | "metadata": {
658 | "collapsed": false
659 | },
660 | "outputs": [],
661 | "source": [
662 | "z=u+v\n",
663 | "z"
664 | ]
665 | },
666 | {
667 | "cell_type": "markdown",
668 | "metadata": {},
669 | "source": [
670 | " The operation is equivalent to vector addition:"
671 | ]
672 | },
673 | {
674 | "cell_type": "code",
675 | "execution_count": null,
676 | "metadata": {
677 | "collapsed": false
678 | },
679 | "outputs": [],
680 | "source": [
681 | "Plotvec1(u,z,v)"
682 | ]
683 | },
684 | {
685 | "cell_type": "markdown",
686 | "metadata": {},
687 | "source": [
688 | "#### Implement the following vector subtraction in numpy: u-v "
689 | ]
690 | },
691 | {
692 | "cell_type": "code",
693 | "execution_count": null,
694 | "metadata": {
695 | "collapsed": false
696 | },
697 | "outputs": [],
698 | "source": []
699 | },
700 | {
701 | "cell_type": "markdown",
702 | "metadata": {},
703 | "source": [
704 | " ![](\"http://akhavanpour.ir/notebook/python-labs/numpy-3.gif\")
"
1105 | ]
1106 | },
1107 | {
1108 | "cell_type": "markdown",
1109 | "metadata": {},
1110 | "source": [
1111 | " This part of Broadcasting check out the link for more detail. "
1112 | ]
1113 | },
1114 | {
1115 | "cell_type": "markdown",
1116 | "metadata": {},
1117 | "source": [
1118 | "### Mathematical Functions "
1119 | ]
1120 | },
1121 | {
1122 | "cell_type": "markdown",
1123 | "metadata": {},
1124 | "source": [
1125 | " We can access the value of pie in numpy as follows :"
1126 | ]
1127 | },
1128 | {
1129 | "cell_type": "code",
1130 | "execution_count": null,
1131 | "metadata": {
1132 | "collapsed": false
1133 | },
1134 | "outputs": [],
1135 | "source": [
1136 | "np.pi"
1137 | ]
1138 | },
1139 | {
1140 | "cell_type": "markdown",
1141 | "metadata": {},
1142 | "source": [
1143 | " We can create the following numpy array in Radians:"
1144 | ]
1145 | },
1146 | {
1147 | "cell_type": "code",
1148 | "execution_count": null,
1149 | "metadata": {
1150 | "collapsed": false
1151 | },
1152 | "outputs": [],
1153 | "source": [
1154 | "x=np.array([0,np.pi/2 , np.pi] )"
1155 | ]
1156 | },
1157 | {
1158 | "cell_type": "markdown",
1159 | "metadata": {},
1160 | "source": [
1161 | " We can apply the function \"sine\" to the array 'x' and assign the values to the array 'y'; this applies the sine function to each element in the array: "
1162 | ]
1163 | },
1164 | {
1165 | "cell_type": "code",
1166 | "execution_count": null,
1167 | "metadata": {
1168 | "collapsed": false
1169 | },
1170 | "outputs": [],
1171 | "source": [
1172 | "y=np.sin(x)\n",
1173 | "y"
1174 | ]
1175 | },
1176 | {
1177 | "cell_type": "markdown",
1178 | "metadata": {},
1179 | "source": [
1180 | "#### Linspace"
1181 | ]
1182 | },
1183 | {
1184 | "cell_type": "markdown",
1185 | "metadata": {},
1186 | "source": [
1187 | " A useful function for plotting mathematical functions is \"linespace\". Linespace returns evenly spaced numbers over a specified interval. We specify the starting point of the sequence and the ending point of the sequence. The parameter \"num\" indicates the Number of samples to generate, in this case 5:"
1188 | ]
1189 | },
1190 | {
1191 | "cell_type": "code",
1192 | "execution_count": null,
1193 | "metadata": {
1194 | "collapsed": false
1195 | },
1196 | "outputs": [],
1197 | "source": [
1198 | "np.linspace(-2,2,num=5)"
1199 | ]
1200 | },
1201 | {
1202 | "cell_type": "markdown",
1203 | "metadata": {},
1204 | "source": [
1205 | " If we change the parameter **num** to 9, we get 9 evenly spaced numbers over the interval from -2 to 2: "
1206 | ]
1207 | },
1208 | {
1209 | "cell_type": "code",
1210 | "execution_count": null,
1211 | "metadata": {
1212 | "collapsed": false
1213 | },
1214 | "outputs": [],
1215 | "source": [
1216 | "np.linspace(-2,2,num=9)"
1217 | ]
1218 | },
1219 | {
1220 | "cell_type": "markdown",
1221 | "metadata": {},
1222 | "source": [
1223 | "We can use the function line space to generate 100 evenly spaced samples from the interval 0 to 2 pi: "
1224 | ]
1225 | },
1226 | {
1227 | "cell_type": "code",
1228 | "execution_count": null,
1229 | "metadata": {
1230 | "collapsed": false
1231 | },
1232 | "outputs": [],
1233 | "source": [
1234 | "x=np.linspace(0,2*np.pi,num=100)\n"
1235 | ]
1236 | },
1237 | {
1238 | "cell_type": "markdown",
1239 | "metadata": {},
1240 | "source": [
1241 | "We can apply the sine function to each element in the array 'x' and assign it to the array 'y': "
1242 | ]
1243 | },
1244 | {
1245 | "cell_type": "code",
1246 | "execution_count": null,
1247 | "metadata": {
1248 | "collapsed": true
1249 | },
1250 | "outputs": [],
1251 | "source": [
1252 | "y=np.sin(x)"
1253 | ]
1254 | },
1255 | {
1256 | "cell_type": "code",
1257 | "execution_count": null,
1258 | "metadata": {
1259 | "collapsed": false
1260 | },
1261 | "outputs": [],
1262 | "source": [
1263 | "plt.plot(x,y)"
1264 | ]
1265 | },
1266 | {
1267 | "cell_type": "markdown",
1268 | "metadata": {},
1269 | "source": [
1270 | "#### About the Authors: \n",
1271 | "\n",
1272 | " [Joseph Santarcangelo]( https://www.linkedin.com/in/joseph-s-50398b136/) has a PhD in Electrical Engineering, his research focused on using machine learning, signal processing, and computer vision to determine how videos impact human cognition. Joseph has been working for IBM since he completed his PhD.\n"
1273 | ]
1274 | },
1275 | {
1276 | "cell_type": "markdown",
1277 | "metadata": {},
1278 | "source": [
1279 | "Copyright © 2017 [cognitiveclass.ai](https:cognitiveclass.ai). This notebook and its source code are released under the terms of the [MIT License](cognitiveclass.ai)."
1280 | ]
1281 | },
1282 | {
1283 | "cell_type": "code",
1284 | "execution_count": null,
1285 | "metadata": {
1286 | "collapsed": true
1287 | },
1288 | "outputs": [],
1289 | "source": []
1290 | }
1291 | ],
1292 | "metadata": {
1293 | "anaconda-cloud": {},
1294 | "kernelspec": {
1295 | "display_name": "Python [default]",
1296 | "language": "python",
1297 | "name": "python3"
1298 | },
1299 | "language_info": {
1300 | "codemirror_mode": {
1301 | "name": "ipython",
1302 | "version": 3
1303 | },
1304 | "file_extension": ".py",
1305 | "mimetype": "text/x-python",
1306 | "name": "python",
1307 | "nbconvert_exporter": "python",
1308 | "pygments_lexer": "ipython3",
1309 | "version": "3.5.2"
1310 | }
1311 | },
1312 | "nbformat": 4,
1313 | "nbformat_minor": 2
1314 | }
1315 |
--------------------------------------------------------------------------------