\n",
28 | "\n",
29 | ""
30 | ]
31 | },
32 | {
33 | "cell_type": "markdown",
34 | "metadata": {},
35 | "source": [
36 | "## Programming Basics Overview\n",
37 | "\n",
38 | "From here on out, you'll focus on using Python in programming mode - you'll write code that you run from an IDE or a calling environment, not interactively from the command-line. As you work through this explanation, copy the code you see and run it to see the results. After you work through these copy-and-paste examples, you'll create your own code in the Activities that follow each section."
39 | ]
40 | },
41 | {
42 | "cell_type": "markdown",
43 | "metadata": {},
44 | "source": [
45 | "![](\"../graphics/cortanalogo.png\")
2.1 - Getting help
\n",
46 | "\n",
47 | "The very first thing you should learn in any language is how to get help. You can [find the help documents on-line](https://docs.python.org/3/index.html), or simply type\n",
48 | " \n",
49 | "`help()`\n",
50 | " \n",
51 | "in your code. For help on a specific topic, put the topic in the parenthesis:\n",
52 | " \n",
53 | " `help(str)`\n",
54 | "\n",
55 | " To see a list of topics, type \n",
56 | "\n",
57 | " `help(topics)`"
58 | ]
59 | },
60 | {
61 | "cell_type": "code",
62 | "execution_count": null,
63 | "metadata": {
64 | "collapsed": true
65 | },
66 | "outputs": [],
67 | "source": [
68 | "# Try it:"
69 | ]
70 | },
71 | {
72 | "cell_type": "markdown",
73 | "metadata": {},
74 | "source": [
75 | "2.2 Code Syntax and Structure
\n",
76 | "\n",
77 | "Let's cover a few basics about how Python code is written. (For a full discussion, check out the [Style Guide for Python, called PEP 8](https://www.python.org/dev/peps/pep-0008/) ) Let's use the \"Zen of Python\" rules from Tim Peters for this course:\n",
78 | "\n",
79 | "\n",
80 | "\n",
81 | " Beautiful is better than ugly.\n",
82 | " Explicit is better than implicit.\n",
83 | " Simple is better than complex.\n",
84 | " Complex is better than complicated.\n",
85 | " Flat is better than nested.\n",
86 | " Sparse is better than dense.\n",
87 | " Readability counts.\n",
88 | " Special cases aren't special enough to break the rules.\n",
89 | " Although practicality beats purity.\n",
90 | " Errors should never pass silently.\n",
91 | " Unless explicitly silenced.\n",
92 | " In the face of ambiguity, refuse the temptation to guess.\n",
93 | " There should be one-- and preferably only one --obvious way to do it.\n",
94 | " Although that way may not be obvious at first unless you're Dutch.\n",
95 | " Now is better than never.\n",
96 | " Although never is often better than right now.\n",
97 | " If the implementation is hard to explain, it's a bad idea.\n",
98 | " If the implementation is easy to explain, it may be a good idea.\n",
99 | " Namespaces are one honking great idea -- let's do more of those!\n",
100 | " --Tim Peters\n",
101 | "\n",
102 | "
\n",
103 | "\n",
104 | "In general, use standard coding practices - don't use keywords for variables, be consistent in your naming (camel-case, lower-case, etc.), comment your code clearly, and understand the general syntax of your language, and follow the principles above. But the most important tip is to at least read the PEP 8 and decide for yourself how well that fits into your Zen.\n",
105 | "\n",
106 | "There is one hard-and-fast rule for Python that you *do* need to be aware of: indentation. You **must** indent your code for classes, functions (or methods), loops, conditions, and lists. You can use a tab or four spaces (spaces are the accepted way to do it) but in any case, you have to be consistent. If you use tabs, you always use tabs. If you use spaces, you have to use that throughout. It's best if you set your IDE to handle that for you, whichever way you go.\n",
107 | "\n",
108 | "Python code files have an extension of `.py`. \n",
109 | "\n",
110 | "Comments in Python start with the hash-tag: `#`. There are no block comments (and this makes us all sad) so each line you want to comment must have a tag in front of that line. Keep the lines short (80 characters or so) so that they don't fall off a single-line display like at the command line."
111 | ]
112 | },
113 | {
114 | "cell_type": "markdown",
115 | "metadata": {},
116 | "source": [
117 | "![](\"../graphics/checkbox.png\")
2.3 Variables
\n",
118 | "\n",
119 | "Variables stand in for replaceable values. Python is not strongly-typed, meaning you can just declare a variable name and set it to a value at the same time, and Python will try and guess what data type you want. You use an `=` sign to assign values, and `==` to compare things.\n",
120 | "\n",
121 | "Quotes \\\" or ticks \\' are fine, just be consistent.\n",
122 | "\n",
123 | "`# There are some keywords to be aware of, but x and y are always good choices.`\n",
124 | "\n",
125 | "`x = \"Buck\" # I'm a string.`\n",
126 | "\n",
127 | "`type(x)`\n",
128 | "\n",
129 | "`y = 10 # I'm an integer.`\n",
130 | "\n",
131 | "`type(y)`\n",
132 | "\n",
133 | "To change the type of a value, just re-enter something else:\n",
134 | "\n",
135 | "`x = \"Buck\" # I'm a string.`\n",
136 | "\n",
137 | "`type(x)`\n",
138 | "\n",
139 | "`x = 10 # Now I'm an integer.`\n",
140 | "\n",
141 | "`type(x)`\n",
142 | "\n",
143 | "Or cast it By implicitly declaring the conversion:\n",
144 | "\n",
145 | "`x = \"10\"`\n",
146 | "\n",
147 | "`type(x)`\n",
148 | "\n",
149 | "`print int(x)`\n",
150 | "\n",
151 | "To concatenate string values, use the `+` sign:\n",
152 | "\n",
153 | "`x = \"Buck\"`\n",
154 | "\n",
155 | "`y = \" Woody\"`\n",
156 | "\n",
157 | "`print(x + y)`"
158 | ]
159 | },
160 | {
161 | "cell_type": "code",
162 | "execution_count": null,
163 | "metadata": {},
164 | "outputs": [],
165 | "source": [
166 | "# Try it:\n"
167 | ]
168 | },
169 | {
170 | "cell_type": "markdown",
171 | "metadata": {},
172 | "source": [
173 | "2.4 Operations and Functions
\n",
174 | "\n",
175 | "Python has the following operators:\n",
176 | "\n",
177 | " Arithmetic Operators\n",
178 | " Comparison (Relational) Operators\n",
179 | " Assignment Operators\n",
180 | " Logical Operators\n",
181 | " Bitwise Operators\n",
182 | " Membership Operators\n",
183 | " Identity Operators\n",
184 | "\n",
185 | "You have the standard operators and functions from most every language. Here are some of the tokens:\n",
186 | "\n",
187 | "\n",
188 | "\n",
189 | " != *= << ^ \n",
190 | " \" + <<= ^= \n",
191 | " \"\"\" += <= `\n",
192 | " % , <> __\n",
193 | " %= - == \n",
194 | " & -= > b\" \n",
195 | " &= . >= b' \n",
196 | " ' ... >> j \n",
197 | " ''' / >>= r\" \n",
198 | " ( // @ r' \n",
199 | " ) //= J |'\n",
200 | " * /= [ |= \n",
201 | " ** : \\ ~ \n",
202 | " **= < ] \n",
203 | "\n",
204 | "
\n",
205 | "\n",
206 | "Wait...that's it? That's all you're going to tell me? *(Hint: use what you've learned):*\n",
207 | "\n",
208 | "`help('symbols')`\n",
209 | "\n",
210 | "Walk through each of these operators carefully - you'll use them when you work with data in the next module.\n"
211 | ]
212 | },
213 | {
214 | "cell_type": "code",
215 | "execution_count": null,
216 | "metadata": {
217 | "collapsed": true
218 | },
219 | "outputs": [],
220 | "source": [
221 | "# Try it:"
222 | ]
223 | },
224 | {
225 | "cell_type": "markdown",
226 | "metadata": {},
227 | "source": [
228 | "![](\"../graphics/aml-logo.png\")
Activity - Programming basics
\n",
229 | "\n",
230 | "Open the **02_ProgrammingBasics.py** file and run the code you see there. The exercises will be marked out using comments:\n",
231 | "\n",
232 | "`# - Section Number`"
233 | ]
234 | },
235 | {
236 | "cell_type": "code",
237 | "execution_count": null,
238 | "metadata": {},
239 | "outputs": [],
240 | "source": [
241 | "# 02_ProgrammingBasics.py\n",
242 | "# Purpose: General Programming exercises for Python \n",
243 | "# Author: Buck Woody\n",
244 | "# Credits and Sources: Inline\n",
245 | "# Last Updated: 27 June 2018\n",
246 | "\n",
247 | "# 2.1 Getting Help\n",
248 | "help()\n",
249 | "help(str)\n",
250 | "\n",
251 | "# - Write code to find help on help\n",
252 | "\n",
253 | "# 2.2 Code Syntax and Structure\n",
254 | "\n",
255 | "# - Python uses spaces to indicate code blocks. Fix the code below:\n",
256 | "x=10\n",
257 | "y=5\n",
258 | "if x > y:\n",
259 | "print(str(x) + \" is greater than \" + str(y))\n",
260 | "\n",
261 | "# - Arguments on first line are forbidden when not using vertical alignment. Fix this code:\n",
262 | "foo = long_function_name(var_one, var_two,\n",
263 | " var_three, var_four)\n",
264 | "\n",
265 | "# operators sit far away from their operands. Fix this code:\n",
266 | "income = (gross_wages +\n",
267 | " taxable_interest +\n",
268 | " (dividends - qualified_dividends) -\n",
269 | " ira_deduction -\n",
270 | " student_loan_interest)\n",
271 | "\n",
272 | "# - The import statement should use separate lines for each effort. You can fix the code below \n",
273 | "# using separate lines or by using the \"from\" statement:\n",
274 | "import sys, os\n",
275 | "\n",
276 | "# - The following code has extra spaces in the wrong places. Fix this code:\n",
277 | "i=i+1\n",
278 | "submitted +=1\n",
279 | "x = x * 2 - 1\n",
280 | "hypot2 = x * x + y * y\n",
281 | "c = (a + b) * (a - b)\n",
282 | "\n",
283 | "# 2.3 Variables \n",
284 | "\n",
285 | "# - Add a line below x=3 that changes the variable x from int to a string\n",
286 | "x=3\n",
287 | "type(x)\n",
288 | "\n",
289 | "# - Write code that prints the string \"This class is awesome\" using variables:\n",
290 | "x=\"is awesome\"\n",
291 | "y=\"This Class\"\n",
292 | "\n",
293 | "# 2.4 Operations and Functions\n",
294 | "\n",
295 | "# - Use some basic operators to write the following code:\n",
296 | "# Assign two variables\n",
297 | "# Add them\n",
298 | "# Subtract 20 from each, add those values together, save that to a new variable\n",
299 | "# Create a new string variable with the text \"The result of my operations are: \"\n",
300 | "# Print out a single string on the screen with the result of the variables \n",
301 | "# showing that result. \n",
302 | "\n",
303 | "# EOF: 02_ProgrammingBasics.py"
304 | ]
305 | },
306 | {
307 | "cell_type": "markdown",
308 | "metadata": {},
309 | "source": [
310 | "![](\"../graphics/thinking.jpg\")
For Further Study
\n",
311 | "\n",
312 | "- The PEP - https://www.python.org/dev/peps/pep-0008/\n",
313 | "- Introduction to the Python Coding Style - http://stackabuse.com/introduction-to-the-python-coding-style/\n",
314 | "- The Microsoft Tutorial and samples for Python - https://code.visualstudio.com/docs/languages/python \n",
315 | "- Coding requirements and standards - PEP - https://www.python.org/dev/peps/pep-0008/\n",
316 | "- Another free online self-paced course - https://www.w3schools.com/python/default.asp \n",
317 | "\n",
318 | "Next, Continue to *03 Working with Data*"
319 | ]
320 | },
321 | {
322 | "cell_type": "code",
323 | "execution_count": null,
324 | "metadata": {},
325 | "outputs": [],
326 | "source": []
327 | }
328 | ],
329 | "metadata": {
330 | "kernelspec": {
331 | "display_name": "Python 3",
332 | "language": "python",
333 | "name": "python3"
334 | },
335 | "language_info": {
336 | "codemirror_mode": {
337 | "name": "ipython",
338 | "version": 3
339 | },
340 | "file_extension": ".py",
341 | "mimetype": "text/x-python",
342 | "name": "python",
343 | "nbconvert_exporter": "python",
344 | "pygments_lexer": "ipython3",
345 | "version": "3.6.5"
346 | }
347 | },
348 | "nbformat": 4,
349 | "nbformat_minor": 2
350 | }
351 |
--------------------------------------------------------------------------------
/PythonForDataProfessionals/notebooks/.ipynb_checkpoints/04 Environments and Deployment-checkpoint.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {
6 | "collapsed": true
7 | },
8 | "source": [
9 | "\n",
10 | "\n",
11 | "# Python for Data Professionals\n",
12 | "\n",
13 | "## 04 Environments and Deployment\n",
14 | "\n",
15 | "\n",
16 | "\n",
17 | "\n",
18 | " - Course Outline
\n",
19 | " - 1 - Overview and Course Setup
\n",
20 | " - 2 - Programming Basics
\n",
21 | " - 3 Working with Data
\n",
22 | " - 4 Deployment and Environments (This section)
\n",
23 | " - 4.1 Conda
\n",
24 | " - 4.2 Pickling
\n",
25 | "\n",
26 | "\n",
27 | ""
28 | ]
29 | },
30 | {
31 | "cell_type": "markdown",
32 | "metadata": {},
33 | "source": [
34 | "The main installation of Python - sometimes called \"Core\" or \"base\" - has a set of parameters it works with. Since it runs on many operating systems, these variables are set and altered in different ways. Here are the primary environment settings on the standard installation of Python:\n",
35 | "\n",
36 | "- PYTHONPATH - Sets the location for the Python interpreter to locate the module files imported into a program.\n",
37 | "- PYTHONHOME - The alternative module search path. \n",
38 | "- PYTHONSTARTUP - The initialization file path ( `.pythonrc.py` ) containing the Python source code. It is executed every time you start the interpreter.\n",
39 | "- PYTHONCASEOK - For the Windows OS, find the first case-insensitive match in an \"import\" statement.\n",
40 | "\n",
41 | "You can show all of the variables by importing the base configuration system library, and then calling a print statement:\n",
42 | "\n",
43 | "`import sysconfig`\n",
44 | "\n",
45 | "`sysconfig.get_config_vars()`\n",
46 | "\n",
47 | "If you want to see just one variable, remember, it's just an array:\n",
48 | "\n",
49 | "`sysconfig.get_config_var('LIBDIR')`"
50 | ]
51 | },
52 | {
53 | "cell_type": "code",
54 | "execution_count": 1,
55 | "metadata": {},
56 | "outputs": [],
57 | "source": [
58 | "# Try it:"
59 | ]
60 | },
61 | {
62 | "cell_type": "markdown",
63 | "metadata": {},
64 | "source": [
65 | "4.1 pip and Conda
\n",
66 | "\n",
67 | "To install new packages, you can build the source code manually, but that's not the way it's most often done. Typically you use a \"package manager\", and the most popular is \"pip\". The pip program installs and configures most of the libraries you will need for the base installation of Python.\n",
68 | "\n",
69 | "You probably already have the pip program. However, to install pip, you can use the [cURL](https://curl.haxx.se/download.html) program to get it:\n",
70 | "\n",
71 | "`curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py`\n",
72 | "\n",
73 | "Then use Python to run the script to install it:\n",
74 | "\n",
75 | "`python get-pip.py`\n",
76 | "\n",
77 | "From there, you can query the packages you have with this command, from the command-line in your operating system:\n",
78 | "\n",
79 | "`pip list`\n",
80 | "\n",
81 | "You can install a package using this command:\n",
82 | "\n",
83 | "`pip install SomePackage # latest version`\n",
84 | "\n",
85 | "`pip install SomePackage==1.0.4 # specific version`\n",
86 | "\n",
87 | "`pip install 'SomePackage>=1.0.4' # minimum version`\n",
88 | "\n",
89 | "And you can remove a package with this command:\n",
90 | "\n",
91 | "`pip uninstall SomePackage`\n",
92 | "\n",
93 | "There is a lot more that you can do with pip, and you can find out the list here:\n",
94 | "\n",
95 | "`pip`\n",
96 | "\n",
97 | "A more robust package manager, which even installs a distribution of Python for you along with other tools, is [Conda](https://conda.io/docs/user-guide/getting-started.html). For this course, you have installed Python using Conda, which not only has a package manager, but also isolates environments for you. This means that you can create a \"boundary\" of variables, package directories, and more around a name you specify. You can then switch to that environment to create your code, and that code will always have a consistent set of variables and packages.\n",
98 | "\n",
99 | "To create a Conda environment, issue the following command:\n",
100 | "\n",
101 | "`conda create --name`\n",
102 | "\n",
103 | "For instance, this command creates a new environment called \"bucktest\" and installs the biology package called biopython:\n",
104 | "\n",
105 | "`conda create --name bucktest biopython`\n",
106 | "\n",
107 | "To see the environments, issue the following command:\n",
108 | "\n",
109 | "`conda info --envs`\n",
110 | "\n",
111 | "The one with the asterisk (*) is the one you are using now. To switch to another environment, issue the following command:\n",
112 | "\n",
113 | "`activate bucktest` (In Windows)\n",
114 | "\n",
115 | "`source activate bucktest` (Mac and Linux)\n",
116 | "\n",
117 | "And to see information about that environment, issue the following command:\n",
118 | "\n",
119 | "`conda list`\n",
120 | "\n",
121 | "or just `conda` to find out everything you can do with Conda.\n",
122 | "\n",
123 | "To install packages in that environment, use this command:\n",
124 | "\n",
125 | "`conda install biopython`"
126 | ]
127 | },
128 | {
129 | "cell_type": "markdown",
130 | "metadata": {},
131 | "source": [
132 | " Activity - pip and Conda
\n",
133 | "\n",
134 | "Now open the `/code/04_EnvironmentsAndDeployment.py` file and follow the instructions you see there for 4.1."
135 | ]
136 | },
137 | {
138 | "cell_type": "code",
139 | "execution_count": 2,
140 | "metadata": {},
141 | "outputs": [],
142 | "source": [
143 | "# 04_EnvironmentsAndDeployments.py\n",
144 | "# Purpose: Environmental settings and configurations\n",
145 | "# Author: Buck Woody\n",
146 | "# Credits and Sources: Inline\n",
147 | "# Last Updated: 07 July 2018\n",
148 | "\n",
149 | "# - 4.1 Show the main environment variables in the current Python environment. Which directory has the libraries?\n",
150 | "\n",
151 | "# - What else can you find in the sysconfig library? How would you find that out?\n",
152 | "\n",
153 | "# - Using conda commands, what libraries are currently loaded? \n",
154 | "# How would you install a new one? \n",
155 | "# What environment are you using now?"
156 | ]
157 | },
158 | {
159 | "cell_type": "markdown",
160 | "metadata": {},
161 | "source": [
162 | "4.2 Pickling
\n",
163 | "\n",
164 | "\"Pickling\" in Python means to serialize a Python object. Perhaps that isn't very helpful - what it really means is to take the output of whatever you did in Python and make it available again in another environment or program. It's a way of saving the \"state\" of a program so that it can be transferred and then re-loaded.\n",
165 | "\n",
166 | "It's best illustrated with some code:\n",
167 | "\n",
168 | "`import pickle`\n",
169 | "\n",
170 | "`a = ['1','2','3']`\n",
171 | "\n",
172 | "`PickleFileName = \"picklefile\"`\n",
173 | "\n",
174 | "`FileObject = open(PickleFileName,'wb')`\n",
175 | "\n",
176 | "`pickle.dump(a,FileObject)`\n",
177 | "\n",
178 | "`fileObject.close()`\n",
179 | "\n",
180 | "Now you can copy that file to a new computer, open Python, and work with it again as if you ran it there:\n",
181 | "\n",
182 | "`import pickle`\n",
183 | "\n",
184 | "`PickleFileName = \"picklefile\"`\n",
185 | "\n",
186 | "`FileObject = open(PickleFileName,'r') ` \n",
187 | "\n",
188 | "`b = pickle.load(FileObject) ` \n",
189 | "\n",
190 | "`b`\n",
191 | "\n",
192 | "And now *a* equals *b*. Of course, your program would be much longer, most often a series of steps, which might for instance do a Machine Learning prediction. \n",
193 | "\n",
194 | "You can read a lot more about pickling here: https://wiki.python.org/moin/UsingPickle"
195 | ]
196 | },
197 | {
198 | "cell_type": "markdown",
199 | "metadata": {},
200 | "source": [
201 | " Activity - Pickle
\n",
202 | "\n",
203 | "Now open the `/code/04_EnvironmentsAndDeployment.py` file and follow the instructions you see there for step 4.2."
204 | ]
205 | },
206 | {
207 | "cell_type": "code",
208 | "execution_count": 4,
209 | "metadata": {},
210 | "outputs": [],
211 | "source": [
212 | "# - 4.2 Create a program that has three text variables. Combine these three into another varaible. \n",
213 | "# Load the pickle library and save the results of the first program as a pkl file.\n",
214 | "# Close the first program, and create another one that opens and reads the pkl file.\n",
215 | "# Combine the final variable from the last program with a next text variable from this program. \n",
216 | "\n",
217 | "# EOF: 04_EnvironmentsAndDeployment.py"
218 | ]
219 | },
220 | {
221 | "cell_type": "markdown",
222 | "metadata": {},
223 | "source": [
224 | "4.3 Docker and Flask
\n",
225 | "\n",
226 | "Two other abstraction levels are useful to think about. You're probably familiar with Virtual Machines - which uses software to emulate hardware. This lets you install a complete new \"computer\" in a computer's OS. One level up from that abstraction layer is a *Container*. A Container goes slightly further by including a very small kernel of an operating system (most often Linux) to operate a runtime - like Python. This provides an even more consistent environment for your application, since it can also include settings and programs above the Python level. \n",
227 | "\n",
228 | "The *Flask* micro-framework for Python isn't technically an abstraction layer, it has more to do with serving your application up to a Web call. You'll often see Docker and Flask used together, so you'll cover it here for completeness. Once again, seeing some code is useful to understand - this example comes from the documentation site:\n",
229 | "\n",
230 | "\n",
231 | "\n",
232 | "from flask import Flask\n",
233 | "app = Flask(__name__)\n",
234 | "\n",
235 | "@app.route('/')\n",
236 | "def hello_world():\n",
237 | " return 'Hello, World!'\n",
238 | "\n",
239 | "\n",
240 | "\n",
241 | "You can probably follow the layout of this code, but there are some specifics here. First, the code imported Flask itself. Next, the code creates an instance of a Flask app, called \"app\" in this case. From there, the route was set to the base URL call - just as in the main part of a web page. And finally, a simple function returns the words \"Hello World!\".\n",
242 | "\n",
243 | "So far, nothing is happening - the code is just on disk. However, you can \"deploy\" the code on a system that is running with these commands (in Linux):\n",
244 | "\n",
245 | "\n",
246 | "$ export FLASK_APP=hello.py\n",
247 | "$ flask run\n",
248 | " * Running on http://127.0.0.1:5000/\n",
249 | "
\n",
250 | "\n",
251 | "OK...so what? Well, in this case, you could open a Web Browser on that system and type in that URL - and you'll see \"Hello World!\" pop up on the screen. Of course, real applications are much more complicated, can take POST and GET operations, and much more. But this is a very convenient way to serve up your Python application without having to tell your users to install and run Python.\n",
252 | "\n",
253 | "Of course, there's a lot more to both of these topics - read the references below to learn more."
254 | ]
255 | },
256 | {
257 | "cell_type": "markdown",
258 | "metadata": {},
259 | "source": [
260 | "For Further Study
\n",
261 | "\n",
262 | "- More on Docker: https://www.fullstackpython.com/docker.html\n",
263 | "- More on Flask: http://flask.pocoo.org/\n",
264 | "- Creating a simple Flask application: http://containertutorials.com/docker-compose/flask-simple-app.html \n",
265 | "\n",
266 | "Congratulations! You now know the basics or working with Python and Data. As you can see, there's a lot more to learn - so use your new knowledge to expand on what you have learned. "
267 | ]
268 | }
269 | ],
270 | "metadata": {
271 | "kernelspec": {
272 | "display_name": "Python 3",
273 | "language": "python",
274 | "name": "python3"
275 | },
276 | "language_info": {
277 | "codemirror_mode": {
278 | "name": "ipython",
279 | "version": 3
280 | },
281 | "file_extension": ".py",
282 | "mimetype": "text/x-python",
283 | "name": "python",
284 | "nbconvert_exporter": "python",
285 | "pygments_lexer": "ipython3",
286 | "version": "3.6.5"
287 | }
288 | },
289 | "nbformat": 4,
290 | "nbformat_minor": 2
291 | }
292 |
--------------------------------------------------------------------------------
/PythonForDataProfessionals/notebooks/00 Pre-Requisites.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {
6 | "collapsed": true
7 | },
8 | "source": [
9 | "\n",
10 | "\n",
11 | "# Python for Data Professionals\n",
12 | "\n",
13 | "![](\"../graphics/SmallBuck.png\")
00 Pre-Requisites
\n",
14 | "\n",
15 | "This \"Python for Data Professionals\" course is taught using [Jupyter Notebooks](https://notebooks.azure.com/help). You'll be able to run the code samples you see by typing in the Python examples as decribed and clicking the \"Run\" button you see at the top of the screen. \n",
16 | "\n",
17 | "For the most part, there are no pre-requisites for this course using a Notebook. However, if you would like to learn this material on your own machine, you'll need Microsoft Windows, SQL Server, and Visual Studio. You can of course use the Python language on many platforms and in other distributions and with other tools, but using this configuration allows you to stay consistent for instruction during this course. Feel free to use other installations after you complete the course.\n",
18 | "\n",
19 | "Read over this section and then proceed to the next notebook."
20 | ]
21 | },
22 | {
23 | "cell_type": "markdown",
24 | "metadata": {},
25 | "source": [
26 | "Activity 1: Set up the Windows Operating System
\n",
27 | "\n",
28 | "You have three options for setting up Microsoft Windows to complete this course. You can use a Local installation of Windows, a Virtual Machine on your local system, or a Virtual Machine stored in a Cloud provider such as Microsoft Azure. *(The third option is only for classrooms where you have reliable connections to the Internet)*\n",
29 | "\n",
30 | "Option 1 - Local Installation
\n",
31 | "\n",
32 | "- Install a recent version of Microsoft Windows. For this course, Windows 10, or any current of Windows Server is acceptable.\n",
33 | "- Install all updates to the operating system.\n",
34 | "\n",
35 | "Option 2 - Install Windows on a Local Virtual Machine Environment
\n",
36 | "\n",
37 | "- Using your local system, [navigate to this resource](https://developer.microsoft.com/en-us/windows/downloads/virtual-machines) and follow the instructions there.\n",
38 | "\n",
39 | "**NOTE: Wait as long as reasonably possible to ensure that the system does not expire - these are free licenses, but they have a time limit**\n",
40 | "\n",
41 | "- You can also use whatever Hypervisor you like for your system and install a legal, registered copy of Microsoft Windows.\n",
42 | "\n",
43 | "Option 3 - Use a Virtual Machine in a Cloud Provider
\n",
44 | "\n",
45 | "- If you have access to the Internet, you can set up a [free Microsoft Azure Account](https://azure.microsoft.com/en-us/free/search/?&OCID=AID631184_SEM_bSHIQHtA&lnkd=Google_Azure_Brand&gclid=Cj0KCQjwpcLZBRCnARIsAMPBgF2myLWEk3Hllm2354GEs0rD1sDST_xcfkFGRdAE8toYZMalbQJ4M3YaAs9UEALw_wcB&dclid=CPDRgcv57tsCFVXE4Qodo-gLzg) and use a [Data Science Virtual Machine](https://docs.microsoft.com/en-us/azure/machine-learning/data-science-virtual-machine/provision-vm). Any size will do, and the free account provides enough resources for a single course. You will not need to install Anaconda, VSCode or SQL Server if you use this choice, as they are already installed for you.\n",
46 | "- Log in to the system and run [Windows Update](https://support.microsoft.com/en-us/help/4027667/windows-update-windows-10)\n",
47 | "\n"
48 | ]
49 | },
50 | {
51 | "cell_type": "markdown",
52 | "metadata": {},
53 | "source": [
54 | "Activity 2: Install SQL Server 2017 with ML Services
\n",
55 | "\n",
56 | "- [Navigate to this resource](https://www.microsoft.com/en-us/sql-server/sql-server-downloads), Select **Developer** from the lower part of the page, and install the **Developer Edition**. Select all components for installation.\n",
57 | "\n",
58 | "- Run Windows Update and select the [\"Install updates for other products\" option](https://www.lifewire.com/how-to-change-windows-update-settings-2625778). Apply the latest updates to the classroom system.\n",
59 | "\n",
60 | "Activity 3: Install Visual Studio with Machine Learning and Data Science workloads
\n",
61 | "\n",
62 | "- On your classroom system, [install Visual Studio 2017](https://www.visualstudio.com/downloads/) - The free Community Edition is adequate for this course.\n",
63 | "\n",
64 | "- During the installation, select the \"Data storage and processing\" and \"Data science and analytical applicaitons\" Workloads. *(NOTE: [In the Data Science Workload installation box, select ALL optional components on the Summary pane!](https://blogs.msdn.microsoft.com/visualstudio/2016/11/18/data-science-workloads-in-visual-studio-2017-rc/))*\n",
65 | "\n",
66 | "- Log in with a Live ID to Visual Studio, let the system load, and apply any updates.\n",
67 | "\n",
68 | "- After the updates complete, click the \"R Tools\" menu item and open the \"Interactive R Window\" option (This will verify that the Data Science Workloads add-ins are working, R and Python). Type the following in that panel to ensure the installation was successful:\n",
69 | "\n"
70 | ]
71 | },
72 | {
73 | "cell_type": "code",
74 | "execution_count": null,
75 | "metadata": {},
76 | "outputs": [],
77 | "source": [
78 | "x <- 10\n",
79 | "\n",
80 | "x\n"
81 | ]
82 | },
83 | {
84 | "cell_type": "markdown",
85 | "metadata": {},
86 | "source": [
87 | "You should see the result **\\[1\\]10** returned. If not, open the Visual Studio Installer and select the \"Repair\" option."
88 | ]
89 | },
90 | {
91 | "cell_type": "markdown",
92 | "metadata": {},
93 | "source": [
94 | "For Further Study
\n",
95 | "\n",
96 | "- Platforms supported: https://www.python.org/download/other/ \n",
97 | "\n",
98 | "- Installing Python: https://www.python.org/downloads/\n",
99 | "\n",
100 | "- Installing Python using Anaconda: https://www.infoworld.com/article/3267976/python/anaconda-cpython-pypy-and-more-know-your-python-distributions.html\n",
101 | "\n",
102 | "Next, Continue to *01 Overview and Course Setup*"
103 | ]
104 | }
105 | ],
106 | "metadata": {
107 | "kernelspec": {
108 | "display_name": "Python 3",
109 | "language": "python",
110 | "name": "python3"
111 | },
112 | "language_info": {
113 | "codemirror_mode": {
114 | "name": "ipython",
115 | "version": 3
116 | },
117 | "file_extension": ".py",
118 | "mimetype": "text/x-python",
119 | "name": "python",
120 | "nbconvert_exporter": "python",
121 | "pygments_lexer": "ipython3",
122 | "version": "3.6.5"
123 | }
124 | },
125 | "nbformat": 4,
126 | "nbformat_minor": 2
127 | }
128 |
--------------------------------------------------------------------------------
/PythonForDataProfessionals/notebooks/01 Overview and Setup.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {
6 | "collapsed": true
7 | },
8 | "source": [
9 | "\n",
10 | "\n",
11 | "# Python for Data Professionals\n",
12 | "\n",
13 | "## 01 Overview and Setup\n",
14 | "\n",
15 | "In this course you'll cover the basics of the Python language and environment from a Data Professional's perspective. While you will learn Python, you'll quickly cover topics that have a lot more depth available. In each section you'll get more references to go deeper, which you should follow up on. Also watch for links within the text - click on each one to explore that topic.\n",
16 | "\n",
17 | "Make sure you check out the **00 Pre-Requisites** page before you start. You'll need all of the items loaded there before you can proceed with the course.\n",
18 | "\n",
19 | "You'll cover these topics in the course:\n",
20 | "\n",
21 | "\n",
22 | "\n",
23 | "\n",
24 | " - Course Outline
\n",
25 | " - 1 - Overview and Course Setup (This section)
\n",
26 | " - 2 - Programming Basics
\n",
27 | " - 3 Working with Data
\n",
28 | " - 4 Deployment and Environments
\n",
29 | "\n",
30 | "\n",
31 | ""
32 | ]
33 | },
34 | {
35 | "cell_type": "markdown",
36 | "metadata": {},
37 | "source": [
38 | " Overview
\n",
39 | "\n",
40 | "There are two main versions of Python - 2 and 3. So many programs were written for version 2 that it is still around, and version 3 was such an upgrade that programs for 2 don't always run in 3 and visa-versa. For this course we'll do everything in version 3 - it's becoming the accepted standard for data professionals.\n",
41 | "\n",
42 | "You have a few ways of working with Python:\n",
43 | "\n",
44 | "- The Interactive Interpreter (Type `python` and the version number if it is in your path)\n",
45 | "- Writing code and running it in some graphical environment (Such as VSCode, Visual Studio, Spyder, PyCharm, IDLE, etc.)\n",
46 | "- Calling a `.py` script file from the `python` command \n",
47 | "\n",
48 | "When you're in command-mode, you'll see that the code looks more like a scripting language, meaning that some parenthesis around functions might not be there. Programming-mode looks like a standard programming language environment - you'll normally use that within an Integrated Programming Environment (IDE)."
49 | ]
50 | },
51 | {
52 | "cell_type": "markdown",
53 | "metadata": {},
54 | "source": [
55 | "Activity: Verify Your Installation and Configure Python
\n",
56 | "\n",
57 | "Open the **01_OverviewAndCourseSetup.py** file and run the code you see there. The exercises will be marked out using comments: \n",
58 | "\n",
59 | "\n",
60 | "# TODO - Section Number\n",
61 | "
"
62 | ]
63 | },
64 | {
65 | "cell_type": "code",
66 | "execution_count": 1,
67 | "metadata": {},
68 | "outputs": [
69 | {
70 | "ename": "SyntaxError",
71 | "evalue": "Missing parentheses in call to 'print'. Did you mean print(\"The Python Version is: \" python_version)? (, line 14)",
72 | "output_type": "error",
73 | "traceback": [
74 | "\u001b[1;36m File \u001b[1;32m\"\"\u001b[1;36m, line \u001b[1;32m14\u001b[0m\n\u001b[1;33m print \"The Python Version is: \" python_version\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m Missing parentheses in call to 'print'. Did you mean print(\"The Python Version is: \" python_version)?\n"
75 | ]
76 | }
77 | ],
78 | "source": [
79 | "# 01_OverviewAndCourseSetup.py\n",
80 | "# Purpose: Initial Course Setup and displaying versions\n",
81 | "# Author: Buck Woody\n",
82 | "# Credits and Sources: Inline\n",
83 | "# Last Updated: 27 June 2018\n",
84 | "\n",
85 | "# Check the Python Version and Information\n",
86 | "import platform\n",
87 | "python_version=platform.python_version()\n",
88 | "print(python_version)\n",
89 | "\n",
90 | "# - Fix this code so that it runs\n",
91 | "\n",
92 | "print \"The Python Version is: \" python_version\n",
93 | "\n",
94 | "# - Using \"platform\", what other information can you derive about this system?\n",
95 | "\n",
96 | "# EOF: 01_OverviewAndCourseSetup.py"
97 | ]
98 | },
99 | {
100 | "cell_type": "markdown",
101 | "metadata": {},
102 | "source": [
103 | "For Further Study
\n",
104 | "\n",
105 | "- Version differences: https://wiki.python.org/moin/Python2orPython3 \n",
106 | "- Development Environments: IDLE, tk, VSCode, PyCharm, Jupyter Notebooks, Documentation, Training Resources: https://www.python.org/doc/\n",
107 | "- and https://docs.python.org/3/tutorial/index.html \n",
108 | "- The Official Python Documentation Course: https://docs.python.org/3/tutorial/index.html\n",
109 | "\n",
110 | "Next, Continue to *02 Programming Basics*"
111 | ]
112 | },
113 | {
114 | "cell_type": "code",
115 | "execution_count": null,
116 | "metadata": {},
117 | "outputs": [],
118 | "source": []
119 | }
120 | ],
121 | "metadata": {
122 | "kernelspec": {
123 | "display_name": "Python 3",
124 | "language": "python",
125 | "name": "python3"
126 | },
127 | "language_info": {
128 | "codemirror_mode": {
129 | "name": "ipython",
130 | "version": 3
131 | },
132 | "file_extension": ".py",
133 | "mimetype": "text/x-python",
134 | "name": "python",
135 | "nbconvert_exporter": "python",
136 | "pygments_lexer": "ipython3",
137 | "version": "3.6.5"
138 | }
139 | },
140 | "nbformat": 4,
141 | "nbformat_minor": 2
142 | }
143 |
--------------------------------------------------------------------------------
/PythonForDataProfessionals/notebooks/02 Programming Basics.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {
6 | "collapsed": true
7 | },
8 | "source": [
9 | "\n",
10 | "\n",
11 | "# Python for Data Professionals\n",
12 | "\n",
13 | "## 02 Programming Basics\n",
14 | "\n",
15 | "\n",
16 | "\n",
17 | "\n",
18 | " - Course Outline
\n",
19 | " - 1 - Overview and Course Setup
\n",
20 | " - 2 - Programming Basics (This section)
\n",
21 | " - 2.1 - Getting help
\n",
22 | " - 2.2 Code Syntax and Structure
\n",
23 | " - 2.3 Variables
- \n",
24 | "
- 2.4 Operations and Functions
- \n",
25 | "
- 3 Working with Data
\n",
26 | " - 4 Deployment and Environments
\n",
27 | "\n",
28 | "\n",
29 | ""
30 | ]
31 | },
32 | {
33 | "cell_type": "markdown",
34 | "metadata": {},
35 | "source": [
36 | "## Programming Basics Overview\n",
37 | "\n",
38 | "From here on out, you'll focus on using Python in programming mode - you'll write code that you run from an IDE or a calling environment, not interactively from the command-line. As you work through this explanation, copy the code you see and run it to see the results. After you work through these copy-and-paste examples, you'll create your own code in the Activities that follow each section."
39 | ]
40 | },
41 | {
42 | "cell_type": "markdown",
43 | "metadata": {},
44 | "source": [
45 | "2.1 - Getting help
\n",
46 | "\n",
47 | "The very first thing you should learn in any language is how to get help. You can [find the help documents on-line](https://docs.python.org/3/index.html), or simply type\n",
48 | " \n",
49 | "`help()`\n",
50 | " \n",
51 | "in your code. For help on a specific topic, put the topic in the parenthesis:\n",
52 | " \n",
53 | " `help(str)`\n",
54 | "\n",
55 | " To see a list of topics, type \n",
56 | "\n",
57 | " `help(topics)`"
58 | ]
59 | },
60 | {
61 | "cell_type": "code",
62 | "execution_count": null,
63 | "metadata": {},
64 | "outputs": [],
65 | "source": [
66 | "# Try it:\n",
67 | "help(topics)"
68 | ]
69 | },
70 | {
71 | "cell_type": "markdown",
72 | "metadata": {},
73 | "source": [
74 | "2.2 Code Syntax and Structure
\n",
75 | "\n",
76 | "Let's cover a few basics about how Python code is written. (For a full discussion, check out the [Style Guide for Python, called PEP 8](https://www.python.org/dev/peps/pep-0008/) ) Let's use the \"Zen of Python\" rules from Tim Peters for this course:\n",
77 | "\n",
78 | "\n",
79 | "\n",
80 | " Beautiful is better than ugly.\n",
81 | " Explicit is better than implicit.\n",
82 | " Simple is better than complex.\n",
83 | " Complex is better than complicated.\n",
84 | " Flat is better than nested.\n",
85 | " Sparse is better than dense.\n",
86 | " Readability counts.\n",
87 | " Special cases aren't special enough to break the rules.\n",
88 | " Although practicality beats purity.\n",
89 | " Errors should never pass silently.\n",
90 | " Unless explicitly silenced.\n",
91 | " In the face of ambiguity, refuse the temptation to guess.\n",
92 | " There should be one-- and preferably only one --obvious way to do it.\n",
93 | " Although that way may not be obvious at first unless you're Dutch.\n",
94 | " Now is better than never.\n",
95 | " Although never is often better than right now.\n",
96 | " If the implementation is hard to explain, it's a bad idea.\n",
97 | " If the implementation is easy to explain, it may be a good idea.\n",
98 | " Namespaces are one honking great idea -- let's do more of those!\n",
99 | " --Tim Peters\n",
100 | "\n",
101 | "
\n",
102 | "\n",
103 | "In general, use standard coding practices - don't use keywords for variables, be consistent in your naming (camel-case, lower-case, etc.), comment your code clearly, and understand the general syntax of your language, and follow the principles above. But the most important tip is to at least read the PEP 8 and decide for yourself how well that fits into your Zen.\n",
104 | "\n",
105 | "There is one hard-and-fast rule for Python that you *do* need to be aware of: indentation. You **must** indent your code for classes, functions (or methods), loops, conditions, and lists. You can use a tab or four spaces (spaces are the accepted way to do it) but in any case, you have to be consistent. If you use tabs, you always use tabs. If you use spaces, you have to use that throughout. It's best if you set your IDE to handle that for you, whichever way you go.\n",
106 | "\n",
107 | "Python code files have an extension of `.py`. \n",
108 | "\n",
109 | "Comments in Python start with the hash-tag: `#`. There are no block comments (and this makes us all sad) so each line you want to comment must have a tag in front of that line. Keep the lines short (80 characters or so) so that they don't fall off a single-line display like at the command line."
110 | ]
111 | },
112 | {
113 | "cell_type": "markdown",
114 | "metadata": {},
115 | "source": [
116 | "2.3 Variables
\n",
117 | "\n",
118 | "Variables stand in for replaceable values. Python is not strongly-typed, meaning you can just declare a variable name and set it to a value at the same time, and Python will try and guess what data type you want. You use an `=` sign to assign values, and `==` to compare things.\n",
119 | "\n",
120 | "Quotes \\\" or ticks \\' are fine, just be consistent.\n",
121 | "\n",
122 | "`# There are some keywords to be aware of, but x and y are always good choices.`\n",
123 | "\n",
124 | "`x = \"Buck\" # I'm a string.`\n",
125 | "\n",
126 | "`type(x)`\n",
127 | "\n",
128 | "`y = 10 # I'm an integer.`\n",
129 | "\n",
130 | "`type(y)`\n",
131 | "\n",
132 | "To change the type of a value, just re-enter something else:\n",
133 | "\n",
134 | "`x = \"Buck\" # I'm a string.`\n",
135 | "\n",
136 | "`type(x)`\n",
137 | "\n",
138 | "`x = 10 # Now I'm an integer.`\n",
139 | "\n",
140 | "`type(x)`\n",
141 | "\n",
142 | "Or cast it By implicitly declaring the conversion:\n",
143 | "\n",
144 | "`x = \"10\"`\n",
145 | "\n",
146 | "`type(x)`\n",
147 | "\n",
148 | "`print int(x)`\n",
149 | "\n",
150 | "To concatenate string values, use the `+` sign:\n",
151 | "\n",
152 | "`x = \"Buck\"`\n",
153 | "\n",
154 | "`y = \" Woody\"`\n",
155 | "\n",
156 | "`print(x + y)`"
157 | ]
158 | },
159 | {
160 | "cell_type": "code",
161 | "execution_count": null,
162 | "metadata": {},
163 | "outputs": [],
164 | "source": [
165 | "# Try it:\n",
166 | "x = \"Buck\" # I'm a string.\n",
167 | "\n",
168 | "type(x)\n",
169 | "\n",
170 | "x = 10 # Now I'm an integer.\n",
171 | "\n",
172 | "type(x)"
173 | ]
174 | },
175 | {
176 | "cell_type": "markdown",
177 | "metadata": {},
178 | "source": [
179 | "2.4 Operations and Functions
\n",
180 | "\n",
181 | "Python has the following operators:\n",
182 | "\n",
183 | " Arithmetic Operators\n",
184 | " Comparison (Relational) Operators\n",
185 | " Assignment Operators\n",
186 | " Logical Operators\n",
187 | " Bitwise Operators\n",
188 | " Membership Operators\n",
189 | " Identity Operators\n",
190 | "\n",
191 | "You have the standard operators and functions from most every language. Here are some of the tokens:\n",
192 | "\n",
193 | "\n",
194 | "\n",
195 | " != *= << ^ \n",
196 | " \" + <<= ^= \n",
197 | " \"\"\" += <= `\n",
198 | " % , <> __\n",
199 | " %= - == \n",
200 | " & -= > b\" \n",
201 | " &= . >= b' \n",
202 | " ' ... >> j \n",
203 | " ''' / >>= r\" \n",
204 | " ( // @ r' \n",
205 | " ) //= J |'\n",
206 | " * /= [ |= \n",
207 | " ** : \\ ~ \n",
208 | " **= < ] \n",
209 | "\n",
210 | "
\n",
211 | "\n",
212 | "Wait...that's it? That's all you're going to tell me? *(Hint: use what you've learned):*\n",
213 | "\n",
214 | "`help('symbols')`\n",
215 | "\n",
216 | "Walk through each of these operators carefully - you'll use them when you work with data in the next module.\n"
217 | ]
218 | },
219 | {
220 | "cell_type": "code",
221 | "execution_count": null,
222 | "metadata": {
223 | "collapsed": true
224 | },
225 | "outputs": [],
226 | "source": [
227 | "# Try it:"
228 | ]
229 | },
230 | {
231 | "cell_type": "markdown",
232 | "metadata": {},
233 | "source": [
234 | "Activity - Programming basics
\n",
235 | "\n",
236 | "Open the **02_ProgrammingBasics.py** file and run the code you see there. The exercises will be marked out using comments:\n",
237 | "\n",
238 | "`# - Section Number`"
239 | ]
240 | },
241 | {
242 | "cell_type": "code",
243 | "execution_count": null,
244 | "metadata": {},
245 | "outputs": [],
246 | "source": [
247 | "# 02_ProgrammingBasics.py\n",
248 | "# Purpose: General Programming exercises for Python \n",
249 | "# Author: Buck Woody\n",
250 | "# Credits and Sources: Inline\n",
251 | "# Last Updated: 27 June 2018\n",
252 | "\n",
253 | "# 2.1 Getting Help\n",
254 | "help()\n",
255 | "help(str)\n",
256 | "\n",
257 | "# - Write code to find help on help\n",
258 | "\n",
259 | "# 2.2 Code Syntax and Structure\n",
260 | "\n",
261 | "# - Python uses spaces to indicate code blocks. Fix the code below:\n",
262 | "x=10\n",
263 | "y=5\n",
264 | "if x > y:\n",
265 | "print(str(x) + \" is greater than \" + str(y))\n",
266 | "\n",
267 | "# - Arguments on first line are forbidden when not using vertical alignment. Fix this code:\n",
268 | "foo = long_function_name(var_one, var_two,\n",
269 | " var_three, var_four)\n",
270 | "\n",
271 | "# operators sit far away from their operands. Fix this code:\n",
272 | "income = (gross_wages +\n",
273 | " taxable_interest +\n",
274 | " (dividends - qualified_dividends) -\n",
275 | " ira_deduction -\n",
276 | " student_loan_interest)\n",
277 | "\n",
278 | "# - The import statement should use separate lines for each effort. You can fix the code below \n",
279 | "# using separate lines or by using the \"from\" statement:\n",
280 | "import sys, os\n",
281 | "\n",
282 | "# - The following code has extra spaces in the wrong places. Fix this code:\n",
283 | "i=i+1\n",
284 | "submitted +=1\n",
285 | "x = x * 2 - 1\n",
286 | "hypot2 = x * x + y * y\n",
287 | "c = (a + b) * (a - b)\n",
288 | "\n",
289 | "# 2.3 Variables \n",
290 | "\n",
291 | "# - Add a line below x=3 that changes the variable x from int to a string\n",
292 | "x=3\n",
293 | "type(x)\n",
294 | "\n",
295 | "# - Write code that prints the string \"This class is awesome\" using variables:\n",
296 | "x=\"is awesome\"\n",
297 | "y=\"This Class\"\n",
298 | "\n",
299 | "# 2.4 Operations and Functions\n",
300 | "\n",
301 | "# - Use some basic operators to write the following code:\n",
302 | "# Assign two variables\n",
303 | "# Add them\n",
304 | "# Subtract 20 from each, add those values together, save that to a new variable\n",
305 | "# Create a new string variable with the text \"The result of my operations are: \"\n",
306 | "# Print out a single string on the screen with the result of the variables \n",
307 | "# showing that result. \n",
308 | "\n",
309 | "# EOF: 02_ProgrammingBasics.py"
310 | ]
311 | },
312 | {
313 | "cell_type": "markdown",
314 | "metadata": {},
315 | "source": [
316 | "For Further Study
\n",
317 | "\n",
318 | "- The PEP - https://www.python.org/dev/peps/pep-0008/\n",
319 | "- Introduction to the Python Coding Style - http://stackabuse.com/introduction-to-the-python-coding-style/\n",
320 | "- The Microsoft Tutorial and samples for Python - https://code.visualstudio.com/docs/languages/python \n",
321 | "- Coding requirements and standards - PEP - https://www.python.org/dev/peps/pep-0008/\n",
322 | "- Another free online self-paced course - https://www.w3schools.com/python/default.asp \n",
323 | "\n",
324 | "Next, Continue to *03 Working with Data*"
325 | ]
326 | },
327 | {
328 | "cell_type": "code",
329 | "execution_count": null,
330 | "metadata": {},
331 | "outputs": [],
332 | "source": []
333 | }
334 | ],
335 | "metadata": {
336 | "kernelspec": {
337 | "display_name": "Python 3",
338 | "language": "python",
339 | "name": "python3"
340 | },
341 | "language_info": {
342 | "codemirror_mode": {
343 | "name": "ipython",
344 | "version": 3
345 | },
346 | "file_extension": ".py",
347 | "mimetype": "text/x-python",
348 | "name": "python",
349 | "nbconvert_exporter": "python",
350 | "pygments_lexer": "ipython3",
351 | "version": "3.6.5"
352 | }
353 | },
354 | "nbformat": 4,
355 | "nbformat_minor": 2
356 | }
357 |
--------------------------------------------------------------------------------
/PythonForDataProfessionals/notebooks/04 Environments and Deployment.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {
6 | "collapsed": true
7 | },
8 | "source": [
9 | "\n",
10 | "\n",
11 | "# Python for Data Professionals\n",
12 | "\n",
13 | "## 04 Environments and Deployment\n",
14 | "\n",
15 | "\n",
16 | "\n",
17 | "\n",
18 | " - Course Outline
\n",
19 | " - 1 - Overview and Course Setup
\n",
20 | " - 2 - Programming Basics
\n",
21 | " - 3 Working with Data
\n",
22 | " - 4 Deployment and Environments (This section)
\n",
23 | " - 4.1 Conda
\n",
24 | " - 4.2 Pickling
\n",
25 | "\n",
26 | "\n",
27 | ""
28 | ]
29 | },
30 | {
31 | "cell_type": "markdown",
32 | "metadata": {},
33 | "source": [
34 | "The main installation of Python - sometimes called \"Core\" or \"base\" - has a set of parameters it works with. Since it runs on many operating systems, these variables are set and altered in different ways. Here are the primary environment settings on the standard installation of Python:\n",
35 | "\n",
36 | "- PYTHONPATH - Sets the location for the Python interpreter to locate the module files imported into a program.\n",
37 | "- PYTHONHOME - The alternative module search path. \n",
38 | "- PYTHONSTARTUP - The initialization file path ( `.pythonrc.py` ) containing the Python source code. It is executed every time you start the interpreter.\n",
39 | "- PYTHONCASEOK - For the Windows OS, find the first case-insensitive match in an \"import\" statement.\n",
40 | "\n",
41 | "You can show all of the variables by importing the base configuration system library, and then calling a print statement:\n",
42 | "\n",
43 | "`import sysconfig`\n",
44 | "\n",
45 | "`sysconfig.get_config_vars()`\n",
46 | "\n",
47 | "If you want to see just one variable, remember, it's just an array:\n",
48 | "\n",
49 | "`sysconfig.get_config_var('LIBDIR')`"
50 | ]
51 | },
52 | {
53 | "cell_type": "code",
54 | "execution_count": 1,
55 | "metadata": {},
56 | "outputs": [],
57 | "source": [
58 | "# Try it:"
59 | ]
60 | },
61 | {
62 | "cell_type": "markdown",
63 | "metadata": {},
64 | "source": [
65 | "4.1 pip and Conda
\n",
66 | "\n",
67 | "To install new packages, you can build the source code manually, but that's not the way it's most often done. Typically you use a \"package manager\", and the most popular is \"pip\". The pip program installs and configures most of the libraries you will need for the base installation of Python.\n",
68 | "\n",
69 | "You probably already have the pip program. However, to install pip, you can use the [cURL](https://curl.haxx.se/download.html) program to get it:\n",
70 | "\n",
71 | "`curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py`\n",
72 | "\n",
73 | "Then use Python to run the script to install it:\n",
74 | "\n",
75 | "`python get-pip.py`\n",
76 | "\n",
77 | "From there, you can query the packages you have with this command, from the command-line in your operating system:\n",
78 | "\n",
79 | "`pip list`\n",
80 | "\n",
81 | "You can install a package using this command:\n",
82 | "\n",
83 | "`pip install SomePackage # latest version`\n",
84 | "\n",
85 | "`pip install SomePackage==1.0.4 # specific version`\n",
86 | "\n",
87 | "`pip install 'SomePackage>=1.0.4' # minimum version`\n",
88 | "\n",
89 | "And you can remove a package with this command:\n",
90 | "\n",
91 | "`pip uninstall SomePackage`\n",
92 | "\n",
93 | "There is a lot more that you can do with pip, and you can find out the list here:\n",
94 | "\n",
95 | "`pip`\n",
96 | "\n",
97 | "A more robust package manager, which even installs a distribution of Python for you along with other tools, is [Conda](https://conda.io/docs/user-guide/getting-started.html). For this course, you have installed Python using Conda, which not only has a package manager, but also isolates environments for you. This means that you can create a \"boundary\" of variables, package directories, and more around a name you specify. You can then switch to that environment to create your code, and that code will always have a consistent set of variables and packages.\n",
98 | "\n",
99 | "To create a Conda environment, issue the following command:\n",
100 | "\n",
101 | "`conda create --name`\n",
102 | "\n",
103 | "For instance, this command creates a new environment called \"bucktest\" and installs the biology package called biopython:\n",
104 | "\n",
105 | "`conda create --name bucktest biopython`\n",
106 | "\n",
107 | "To see the environments, issue the following command:\n",
108 | "\n",
109 | "`conda info --envs`\n",
110 | "\n",
111 | "The one with the asterisk (*) is the one you are using now. To switch to another environment, issue the following command:\n",
112 | "\n",
113 | "`activate bucktest` (In Windows)\n",
114 | "\n",
115 | "`source activate bucktest` (Mac and Linux)\n",
116 | "\n",
117 | "And to see information about that environment, issue the following command:\n",
118 | "\n",
119 | "`conda list`\n",
120 | "\n",
121 | "or just `conda` to find out everything you can do with Conda.\n",
122 | "\n",
123 | "To install packages in that environment, use this command:\n",
124 | "\n",
125 | "`conda install biopython`"
126 | ]
127 | },
128 | {
129 | "cell_type": "markdown",
130 | "metadata": {},
131 | "source": [
132 | " Activity - pip and Conda
\n",
133 | "\n",
134 | "Now open the `/code/04_EnvironmentsAndDeployment.py` file and follow the instructions you see there for 4.1."
135 | ]
136 | },
137 | {
138 | "cell_type": "code",
139 | "execution_count": 2,
140 | "metadata": {},
141 | "outputs": [],
142 | "source": [
143 | "# 04_EnvironmentsAndDeployments.py\n",
144 | "# Purpose: Environmental settings and configurations\n",
145 | "# Author: Buck Woody\n",
146 | "# Credits and Sources: Inline\n",
147 | "# Last Updated: 07 July 2018\n",
148 | "\n",
149 | "# - 4.1 Show the main environment variables in the current Python environment. Which directory has the libraries?\n",
150 | "\n",
151 | "# - What else can you find in the sysconfig library? How would you find that out?\n",
152 | "\n",
153 | "# - Using conda commands, what libraries are currently loaded? \n",
154 | "# How would you install a new one? \n",
155 | "# What environment are you using now?"
156 | ]
157 | },
158 | {
159 | "cell_type": "markdown",
160 | "metadata": {},
161 | "source": [
162 | "4.2 Pickling
\n",
163 | "\n",
164 | "\"Pickling\" in Python means to serialize a Python object. Perhaps that isn't very helpful - what it really means is to take the output of whatever you did in Python and make it available again in another environment or program. It's a way of saving the \"state\" of a program so that it can be transferred and then re-loaded.\n",
165 | "\n",
166 | "It's best illustrated with some code:\n",
167 | "\n",
168 | "`import pickle`\n",
169 | "\n",
170 | "`a = ['1','2','3']`\n",
171 | "\n",
172 | "`PickleFileName = \"picklefile\"`\n",
173 | "\n",
174 | "`FileObject = open(PickleFileName,'wb')`\n",
175 | "\n",
176 | "`pickle.dump(a,FileObject)`\n",
177 | "\n",
178 | "`fileObject.close()`\n",
179 | "\n",
180 | "Now you can copy that file to a new computer, open Python, and work with it again as if you ran it there:\n",
181 | "\n",
182 | "`import pickle`\n",
183 | "\n",
184 | "`PickleFileName = \"picklefile\"`\n",
185 | "\n",
186 | "`FileObject = open(PickleFileName,'r') ` \n",
187 | "\n",
188 | "`b = pickle.load(FileObject) ` \n",
189 | "\n",
190 | "`b`\n",
191 | "\n",
192 | "And now *a* equals *b*. Of course, your program would be much longer, most often a series of steps, which might for instance do a Machine Learning prediction. \n",
193 | "\n",
194 | "You can read a lot more about pickling here: https://wiki.python.org/moin/UsingPickle"
195 | ]
196 | },
197 | {
198 | "cell_type": "markdown",
199 | "metadata": {},
200 | "source": [
201 | " Activity - Pickle
\n",
202 | "\n",
203 | "Now open the `/code/04_EnvironmentsAndDeployment.py` file and follow the instructions you see there for step 4.2."
204 | ]
205 | },
206 | {
207 | "cell_type": "code",
208 | "execution_count": 4,
209 | "metadata": {},
210 | "outputs": [],
211 | "source": [
212 | "# - 4.2 Create a program that has three text variables. Combine these three into another varaible. \n",
213 | "# Load the pickle library and save the results of the first program as a pkl file.\n",
214 | "# Close the first program, and create another one that opens and reads the pkl file.\n",
215 | "# Combine the final variable from the last program with a next text variable from this program. \n",
216 | "\n",
217 | "# EOF: 04_EnvironmentsAndDeployment.py"
218 | ]
219 | },
220 | {
221 | "cell_type": "markdown",
222 | "metadata": {},
223 | "source": [
224 | "4.3 Docker and Flask
\n",
225 | "\n",
226 | "Two other abstraction levels are useful to think about. You're probably familiar with Virtual Machines - which uses software to emulate hardware. This lets you install a complete new \"computer\" in a computer's OS. One level up from that abstraction layer is a *Container*. A Container goes slightly further by including a very small kernel of an operating system (most often Linux) to operate a runtime - like Python. This provides an even more consistent environment for your application, since it can also include settings and programs above the Python level. \n",
227 | "\n",
228 | "The *Flask* micro-framework for Python isn't technically an abstraction layer, it has more to do with serving your application up to a Web call. You'll often see Docker and Flask used together, so you'll cover it here for completeness. Once again, seeing some code is useful to understand - this example comes from the documentation site:\n",
229 | "\n",
230 | "\n",
231 | "\n",
232 | "from flask import Flask\n",
233 | "app = Flask(__name__)\n",
234 | "\n",
235 | "@app.route('/')\n",
236 | "def hello_world():\n",
237 | " return 'Hello, World!'\n",
238 | "\n",
239 | "\n",
240 | "\n",
241 | "You can probably follow the layout of this code, but there are some specifics here. First, the code imported Flask itself. Next, the code creates an instance of a Flask app, called \"app\" in this case. From there, the route was set to the base URL call - just as in the main part of a web page. And finally, a simple function returns the words \"Hello World!\".\n",
242 | "\n",
243 | "So far, nothing is happening - the code is just on disk. However, you can \"deploy\" the code on a system that is running with these commands (in Linux):\n",
244 | "\n",
245 | "\n",
246 | "$ export FLASK_APP=hello.py\n",
247 | "$ flask run\n",
248 | " * Running on http://127.0.0.1:5000/\n",
249 | "
\n",
250 | "\n",
251 | "OK...so what? Well, in this case, you could open a Web Browser on that system and type in that URL - and you'll see \"Hello World!\" pop up on the screen. Of course, real applications are much more complicated, can take POST and GET operations, and much more. But this is a very convenient way to serve up your Python application without having to tell your users to install and run Python.\n",
252 | "\n",
253 | "Of course, there's a lot more to both of these topics - read the references below to learn more."
254 | ]
255 | },
256 | {
257 | "cell_type": "markdown",
258 | "metadata": {},
259 | "source": [
260 | "For Further Study
\n",
261 | "\n",
262 | "- More on Docker: https://www.fullstackpython.com/docker.html\n",
263 | "- More on Flask: http://flask.pocoo.org/\n",
264 | "- Creating a simple Flask application: http://containertutorials.com/docker-compose/flask-simple-app.html \n",
265 | "\n",
266 | "Congratulations! You now know the basics or working with Python and Data. As you can see, there's a lot more to learn - so use your new knowledge to expand on what you have learned. "
267 | ]
268 | }
269 | ],
270 | "metadata": {
271 | "kernelspec": {
272 | "display_name": "Python 3",
273 | "language": "python",
274 | "name": "python3"
275 | },
276 | "language_info": {
277 | "codemirror_mode": {
278 | "name": "ipython",
279 | "version": 3
280 | },
281 | "file_extension": ".py",
282 | "mimetype": "text/x-python",
283 | "name": "python",
284 | "nbconvert_exporter": "python",
285 | "pygments_lexer": "ipython3",
286 | "version": "3.6.5"
287 | }
288 | },
289 | "nbformat": 4,
290 | "nbformat_minor": 2
291 | }
292 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | 
2 |
3 | # Lab: Python Basics for Data Professionals
4 |
5 | #### A Microsoft Course from the SQL Server team
6 |
7 |
8 |
9 |
10 |
11 | - About this lab
12 | - Business Applications of this lab
13 | - Technologies used in this lab
14 | - Before Taking this lab
15 | - lab Details
16 | - Related labs
17 | - Lab Modules
18 | - Next Steps
19 |
20 |
21 |
22 | 
23 |
24 | > NOTE: This course is in active re-development. [The course files are complete, and located here](https://github.com/microsoft/sqlworkshops-pythonfordatapros/tree/master/PythonForDataProfessionals), but this page is currently being worked on.
25 |
26 | Welcome to this Microsoft solutions lab on the architecture on *Python Basics for the Data Professional*. In this lab, you'll learn basic Python structures, programming and data flow. You'll get resources to go much further in your learning journey, but this short lab will get you up and running quickly.
27 |
28 | The focus of this lab is to familiarize the database professional in the basics of Python, while implementing it in SQL Server Stored Procedures using SQL Server's Machine Learning Services. After this basic introduction, the professional can move on to more in-depth training in Python if desired.
29 |
30 | You'll start by setting up your system to work with Python, then move to understanding the course itself. From there, you will move though programming basics, working with data, and then on to understanding the concepts of Python environments and how to deploy Python code.
31 |
32 | This [github README.MD file](https://lab.github.com/githubtraining/introduction-to-github) explains how the workshop is laid out, what you will learn, and the technologies you will use in this solution. To download this Lab to your local computer, click the **Clone or Download** button you see at the top right side of this page. [More about that process is here](https://help.github.com/en/github/creating-cloning-and-archiving-repositories/cloning-a-repository).
33 |
34 | You can view all of the [courses and other labs our team has created at this link - open in a new tab to find out more.](https://microsoft.github.io/sqllabs/)
35 |
36 |
37 |
38 | 
Learning Objectives
39 |
40 | In this lab you'll learn:
41 | - How to set up a Python environment for SQL Server using Machine Learning Services
42 | - The Basics of programming in Python including code syntax, getting help, variables, operators, and functions
43 | - Working with data structures, and understanding popular data libraries
44 | - Data Ingestion and access
45 | - Machine Learning in Python
46 | - Environments and code deployment
47 |
48 |
49 |
50 | The goal of this lab is to familiarize the data professional with Python environments and programming.
51 |
52 | The concepts and skills taught in this lab form the starting points for:
53 |
54 | - Data professionals that wish to include Python code in their data access and programming
55 | - Security professionals who wish to understand how to securely implement secure Python coding practices
56 | - Anyone interested in learning more about programming with Python and databases
57 |
58 |
59 |
60 | 
61 |
62 | Businesses require the ability to securely access their data for many workloads, including various programming languages. Python (along with the R language) has merged as a powerful tool for data ingestion, processing and analysis. Previously, Python programmers accessed various databases and retrieved data over a network connection like any application, but this often means pulling large amounts of data over a potentially insecure network to bring multiple copies to each developer to work with locally. The SQL Server Machine Learning Services feature allows Python code to run inside a Stored Procedure in SQL Server, which then accesses data directly. This also allows the Python developer to create code locally, and then send that code on to the Database Administrator for installation on the server - the developer never has to touch the production server or data.
63 |
64 | This couse explains how to work with Python, and then how to operationalize the code on a SQL Server.
65 |
66 |
67 |
68 |
69 | 
70 |
71 | The solution includes the following technologies - although you are not limited to these, they form the basis of the lab. At the end of the lab you will learn how to extrapolate these components into other solutions. You will cover these at an overview level, with references to much deeper training provided.
72 |
73 |
74 | | Technology | Description |
|---|
75 | | Python | *An Open-Source, multiple paradigm coding language with extensible packages |
76 | | Microsoft SQL Server | *A complete data platform, including a Relational Database Management System (RDBMS), Data Pipeline, Business Intelligence, Graph Database Processing, and other constructs to work securely with multiple forms of data, including structured, semi-structured and unstructured. |
77 |
78 |
79 |
80 |
81 |
82 |
83 | 
84 |
85 | You'll need a local system that you are able to install software on. The lab demonstrations use Microsoft Windows as an operating system and all examples use Windows for the lab. Optionally, you can use a Microsoft Azure Virtual Machine (VM) to install the software on and work with the solution.
86 |
87 | This lab expects that you understand data structures and working with SQL Server and computer networks. This lab does not expect you to have any prior data science knowledge, but a basic knowledge of programming and statistics is helpful.
88 |
89 | If you are new to these, here are a few references you can complete prior to class:
90 |
91 | - [Microsoft SQL Server](https://docs.microsoft.com/en-us/sql/relational-databases/database-engine-tutorials?view=sql-server-ver15)
92 | - [Microsoft Azure](https://docs.microsoft.com/en-us/learn/paths/azure-fundamentals/)
93 | - [Basic Programming](https://www.khanacademy.org/computing/computer-programming/programming/intro-to-programming/v/programming-intro)
94 |
95 | 
Setup
96 |
97 | A full prerequisites document is located here. These instructions should be completed before the lab starts, since you will not have time to cover these in class. Remember to turn off any Virtual Machines from the Azure Portal when not taking the class so that you do incur charges (shutting down the machine in the VM itself is not sufficient).
98 |
99 |
100 |
101 | 
102 |
103 | This lab uses the Microsoft Windows operating system, although Linux is also supported once you have completed the exercises.
104 |
105 |
106 |
107 | | Primary Audience: | Data Professionals tasked with implementing Big Data, Machine Learning and AI solutions |
108 | | Secondary Audience: | Security Architects and Developers |
109 | | Level: | 300 |
110 | | Type: | In-Person |
111 | | Length: | 8-9 hours |
112 |
113 |
114 |
115 |
116 |
117 | 
118 |
119 | - This course is also availalbe in a zero-install, online Jupyter Notebook format. [You can find that here](https://notebooks.azure.com/BuckWoodyNoteBooks/projects/PythonDataProfessional).
120 |
121 |
122 |
123 | 
124 |
125 | This is a modular lab, and in each section, you'll learn concepts, technologies and processes to help you complete the solution.
126 |
127 |
128 |
129 | | Module | Topics |
130 |
131 | | 01 - Overview and Course Setup | In this Module you will cover and overview of the Python language and set up your system for the course. |
132 | | 02 - Programming Basics | This Module covers the commands and procedures for getting help in Python, code syntax and structure, variables, and operators and functions. |
133 | | 03 - Working with Data | In this Module you will learn more about data types, ingestion, inpsection, and graphing, with a brief introduction to Data Science with Python. |
134 | | 04 - Environments and Deployment | In this Module you will learn more about Python environments such as Conda, and how to deploy your code using the "pickle" library. |
135 |
136 |
137 |
138 |
139 |
140 | 
Next Steps
141 |
142 | Next, Continue to 00 - Prerequisites
143 |
144 |
145 | # Contributing
146 |
147 | This project welcomes contributions and suggestions. Most contributions require you to agree to a
148 | Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
149 | the rights to use your contribution. For details, visit https://cla.opensource.microsoft.com.
150 |
151 | When you submit a pull request, a CLA bot will automatically determine whether you need to provide
152 | a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions
153 | provided by the bot. You will only need to do this once across all repos using our CLA.
154 |
155 | This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
156 | For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or
157 | contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
158 |
159 | # Legal Notices
160 |
161 | ### License
162 | Microsoft and any contributors grant you a license to the Microsoft documentation and other content in this repository under the [Creative Commons Attribution 4.0 International Public License](https://creativecommons.org/licenses/by/4.0/legalcode), see [the LICENSE file](https://github.com/MicrosoftDocs/mslearn-tailspin-spacegame-web/blob/master/LICENSE), and grant you a license to any code in the repository under [the MIT License](https://opensource.org/licenses/MIT), see the [LICENSE-CODE file](https://github.com/MicrosoftDocs/mslearn-tailspin-spacegame-web/blob/master/LICENSE-CODE).
163 |
164 | Microsoft, Windows, Microsoft Azure and/or other Microsoft products and services referenced in the documentation
165 | may be either trademarks or registered trademarks of Microsoft in the United States and/or other countries.
166 | The licenses for this project do not grant you rights to use any Microsoft names, logos, or trademarks.
167 | Microsoft's general trademark guidelines can be found at http://go.microsoft.com/fwlink/?LinkID=254653.
168 |
169 | Privacy information can be found at https://privacy.microsoft.com/en-us/
170 |
171 | Microsoft and any contributors reserve all other rights, whether under their respective copyrights, patents,
172 | or trademarks, whether by implication, estoppel or otherwise.
173 |
174 |
--------------------------------------------------------------------------------
/SECURITY.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | ## Security
4 |
5 | Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/).
6 |
7 | If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://aka.ms/opensource/security/definition), please report it to us as described below.
8 |
9 | ## Reporting Security Issues
10 |
11 | **Please do not report security vulnerabilities through public GitHub issues.**
12 |
13 | Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://aka.ms/opensource/security/create-report).
14 |
15 | If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com). If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://aka.ms/opensource/security/pgpkey).
16 |
17 | You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://aka.ms/opensource/security/msrc).
18 |
19 | Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
20 |
21 | * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
22 | * Full paths of source file(s) related to the manifestation of the issue
23 | * The location of the affected source code (tag/branch/commit or direct URL)
24 | * Any special configuration required to reproduce the issue
25 | * Step-by-step instructions to reproduce the issue
26 | * Proof-of-concept or exploit code (if possible)
27 | * Impact of the issue, including how an attacker might exploit the issue
28 |
29 | This information will help us triage your report more quickly.
30 |
31 | If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://aka.ms/opensource/security/bounty) page for more details about our active programs.
32 |
33 | ## Preferred Languages
34 |
35 | We prefer all communications to be in English.
36 |
37 | ## Policy
38 |
39 | Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://aka.ms/opensource/security/cvd).
40 |
41 |
42 |
--------------------------------------------------------------------------------
/graphics/AnalyticsAreas.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/sqlworkshops-pythonfordatapros/e7a9fa3dadd492872812c32dc5c030359c3f3905/graphics/AnalyticsAreas.png
--------------------------------------------------------------------------------
/graphics/DataScience.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/sqlworkshops-pythonfordatapros/e7a9fa3dadd492872812c32dc5c030359c3f3905/graphics/DataScience.png
--------------------------------------------------------------------------------
/graphics/MLCapabilities.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/sqlworkshops-pythonfordatapros/e7a9fa3dadd492872812c32dc5c030359c3f3905/graphics/MLCapabilities.png
--------------------------------------------------------------------------------
/graphics/MatPlotLib.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/sqlworkshops-pythonfordatapros/e7a9fa3dadd492872812c32dc5c030359c3f3905/graphics/MatPlotLib.png
--------------------------------------------------------------------------------
/graphics/SmallBuck.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/sqlworkshops-pythonfordatapros/e7a9fa3dadd492872812c32dc5c030359c3f3905/graphics/SmallBuck.png
--------------------------------------------------------------------------------
/graphics/aml-logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/sqlworkshops-pythonfordatapros/e7a9fa3dadd492872812c32dc5c030359c3f3905/graphics/aml-logo.png
--------------------------------------------------------------------------------
/graphics/brain.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/sqlworkshops-pythonfordatapros/e7a9fa3dadd492872812c32dc5c030359c3f3905/graphics/brain.png
--------------------------------------------------------------------------------
/graphics/check.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/sqlworkshops-pythonfordatapros/e7a9fa3dadd492872812c32dc5c030359c3f3905/graphics/check.png
--------------------------------------------------------------------------------
/graphics/checkbox.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/sqlworkshops-pythonfordatapros/e7a9fa3dadd492872812c32dc5c030359c3f3905/graphics/checkbox.png
--------------------------------------------------------------------------------
/graphics/checkmark.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/sqlworkshops-pythonfordatapros/e7a9fa3dadd492872812c32dc5c030359c3f3905/graphics/checkmark.jpg
--------------------------------------------------------------------------------
/graphics/cortanalogo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/sqlworkshops-pythonfordatapros/e7a9fa3dadd492872812c32dc5c030359c3f3905/graphics/cortanalogo.png
--------------------------------------------------------------------------------
/graphics/files.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/sqlworkshops-pythonfordatapros/e7a9fa3dadd492872812c32dc5c030359c3f3905/graphics/files.jpg
--------------------------------------------------------------------------------
/graphics/ggplot.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/sqlworkshops-pythonfordatapros/e7a9fa3dadd492872812c32dc5c030359c3f3905/graphics/ggplot.png
--------------------------------------------------------------------------------
/graphics/keyboard.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/sqlworkshops-pythonfordatapros/e7a9fa3dadd492872812c32dc5c030359c3f3905/graphics/keyboard.jpg
--------------------------------------------------------------------------------
/graphics/microsoftlogo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/sqlworkshops-pythonfordatapros/e7a9fa3dadd492872812c32dc5c030359c3f3905/graphics/microsoftlogo.png
--------------------------------------------------------------------------------
/graphics/pin.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/sqlworkshops-pythonfordatapros/e7a9fa3dadd492872812c32dc5c030359c3f3905/graphics/pin.jpg
--------------------------------------------------------------------------------
/graphics/solutions-microsoft-logo-small.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/sqlworkshops-pythonfordatapros/e7a9fa3dadd492872812c32dc5c030359c3f3905/graphics/solutions-microsoft-logo-small.png
--------------------------------------------------------------------------------
/graphics/tdsp.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/sqlworkshops-pythonfordatapros/e7a9fa3dadd492872812c32dc5c030359c3f3905/graphics/tdsp.png
--------------------------------------------------------------------------------
/graphics/thinking.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/sqlworkshops-pythonfordatapros/e7a9fa3dadd492872812c32dc5c030359c3f3905/graphics/thinking.jpg
--------------------------------------------------------------------------------
00 Pre-Requisites
Option 1 - Local Installation
For Further Study
Overview
444 | 
450 | 
213 |