|
1 .. 9.3 LO: using python modules (3) |
|
2 .. --------------------------------- |
|
3 .. * executing python scripts from command line |
|
4 .. * import |
|
5 .. * scipy |
|
6 .. * pylab |
|
7 .. * sys |
|
8 .. * STDLIB modules show off |
|
9 |
|
10 ==================== |
|
11 Using Python modules |
|
12 ==================== |
|
13 {{{ show the welcome slide }}} |
|
14 |
|
15 Welcome to the spoken tutorial on using python modules. |
|
16 |
|
17 {{{ switch to next slide, outline slide }}} |
|
18 |
|
19 In this tutorial, we will see how to run python scripts from command |
|
20 line, importing modules, importing scipy and pylab modules. |
|
21 |
|
22 {{{ switch to next slide on executing python scripts from command line }}} |
|
23 |
|
24 Let us create a simple python script to print hello world. Open your |
|
25 text editor and type the following, |
|
26 |
|
27 {{{ open the text editor and type the following }}} |
|
28 :: |
|
29 |
|
30 print "Hello world!" |
|
31 print |
|
32 |
|
33 and save the script as hello.py, |
|
34 |
|
35 {{{ save the script as hello.py }}} |
|
36 |
|
37 Till now we saw how to run a script using the IPython interpreter |
|
38 using the |
|
39 :: |
|
40 |
|
41 %run -i hello.py |
|
42 |
|
43 option, but that is not the correct way of running a python |
|
44 script. |
|
45 |
|
46 The correct method is to run it using the Python interpreter. Open the |
|
47 terminal and navigate to the directory where hello.py is, |
|
48 |
|
49 {{{ open terminal and navigate to directory where hello.py was saved }}} |
|
50 |
|
51 now run the Python script as, |
|
52 :: |
|
53 |
|
54 python hello.py |
|
55 |
|
56 It executed the script and we got the output ``Hello World!``. |
|
57 |
|
58 {{{ highlight ``python filename`` syntax on slide while narrating }}} |
|
59 |
|
60 The syntax is python space filename. |
|
61 |
|
62 Now recall the four plot problem where we plotted four plots in a single |
|
63 figure. Let us run that script from command line. |
|
64 |
|
65 If you don't have the script, |
|
66 |
|
67 {{{ open the four_plot.py file in text editor }}} |
|
68 |
|
69 just pause here and create a python script with the following lines |
|
70 and save it as four_plot.py. |
|
71 |
|
72 Now let us run four_plot.py as a python script. |
|
73 :: |
|
74 |
|
75 python four_plot.py |
|
76 |
|
77 Oops! even though it was supposed to work, it didn't. It gave an error |
|
78 ``linspace()`` is not defined, which means that the function |
|
79 ``linspace()`` is not available in the current name-space. |
|
80 |
|
81 But if you try to run the same script using ``%run -i four_plot.py`` |
|
82 in your IPython interpreter started with the option ``-pylab`` it will |
|
83 work, because the ``-pylab`` option does some work for us by importing |
|
84 the required modules to our name-space when ipython interpreter |
|
85 starts. And thus we don't have to explicitly import modules. |
|
86 |
|
87 So now let us try to fix the problem and run the script in command |
|
88 line, |
|
89 |
|
90 add the following line as the first line in the script, |
|
91 {{{ add the line as first line in four_plot.py and save }}} |
|
92 :: |
|
93 |
|
94 from scipy import * |
|
95 |
|
96 Now let us run the script again, |
|
97 :: |
|
98 |
|
99 python four_plot.py |
|
100 |
|
101 Now it gave another error plot not defined, let us edit the file again |
|
102 and add the line below the line we just added, |
|
103 {{{ add the line as second line in four_plot.py and save }}} |
|
104 :: |
|
105 |
|
106 from pylab import * |
|
107 |
|
108 And run the script, |
|
109 :: |
|
110 |
|
111 python four_plot.py |
|
112 |
|
113 Yes! it worked. So what did we do? |
|
114 |
|
115 We actually imported the required modules using the keyword ``import``. |
|
116 It could have also be done as, |
|
117 |
|
118 {{{ highlight the following in slide and say it loud }}} |
|
119 :: |
|
120 |
|
121 from scipy import linspace |
|
122 |
|
123 instead of, |
|
124 :: |
|
125 |
|
126 from scipy import * |
|
127 |
|
128 So in practice it is always good to use function names instead of |
|
129 asterisk or star. As if we use asterisk to import from a particular |
|
130 module then it will replace any existing functions with the same name |
|
131 in our name-space. |
|
132 |
|
133 So let us modify four_plot.py as, |
|
134 {{{ delete the first two lines and add the following }}} |
|
135 :: |
|
136 |
|
137 from scipy import linspace, pi, sin |
|
138 from pylab import plot, legend, annotate, title, show |
|
139 from pylab import xlim, ylim |
|
140 |
|
141 {{{ switch to next slide }}} |
|
142 it could also be done as, |
|
143 |
|
144 .. import scipy |
|
145 .. import pylab |
|
146 .. x = scipy.linspace(-5*scipy.pi, 5*scipy.pi, 500) |
|
147 .. pylab.plot(x, x, 'b') |
|
148 .. pylab.plot(x, -x, 'b') |
|
149 .. pylab.plot(x, scipy.sin(x), 'g', linewidth=2) |
|
150 .. pylab.plot(x, x*scipy.sin(x), 'r', linewidth=3) |
|
151 .. pylab.legend(['x', '-x', 'sin(x)', 'xsin(x)']) |
|
152 .. pylab.annotate('origin', xy = (0, 0)) |
|
153 .. pylab.xlim(-5*scipy.pi, 5*scipy.pi) |
|
154 .. pylab.ylim(-5*scipy.pi, 5*scipy.pi) |
|
155 |
|
156 |
|
157 Notice that we use ``scipy.pi`` instead of just ``pi`` as in the |
|
158 previous method, and the functions are called as ``pylab.plot()`` and |
|
159 ``pylab.annotate()`` and not as ``plot()`` and ``annotate()``. |
|
160 |
|
161 {{{ switch to next slide, problem statement }}} |
|
162 |
|
163 Write a script to plot a sine wave from minus two pi to two pi. |
|
164 |
|
165 Pause here and try to solve the problem yourself before looking at the |
|
166 solution. |
|
167 |
|
168 It can solved as, |
|
169 |
|
170 {{{ open sine.py and show it }}} |
|
171 |
|
172 the first line we import the required functions ``linspace()`` and |
|
173 ``sin()`` and constant ``pi`` from the module scipy. the second and |
|
174 third line we import the functions ``plot()``, ``legend()``, |
|
175 ``show()``, ``title()``, ``xlabel()`` and ``ylabel()``. And the rest |
|
176 the code to generate the plot. |
|
177 |
|
178 We can run it as, |
|
179 {{{ now switch focus to terminal and run the script }}} |
|
180 :: |
|
181 |
|
182 python sine.py |
|
183 |
|
184 {{{ switch to next slide, What is a module? }}} |
|
185 |
|
186 So till now we have been learning about importing modules, now what is |
|
187 a module? |
|
188 |
|
189 A module is simply a file containing Python definitions and |
|
190 statements. Definitions from a module can be imported into other |
|
191 modules or into the main module. |
|
192 |
|
193 {{{ switch to next slide, Python standard library }}} |
|
194 |
|
195 Python has a very rich standard library of modules |
|
196 |
|
197 Python's standard library is very extensive, offering a wide range of |
|
198 facilities. Some of the standard modules are, |
|
199 |
|
200 for Math: math, random |
|
201 for Internet access: urllib2, smtplib |
|
202 for System, Command line arguments: sys |
|
203 for Operating system interface: os |
|
204 for regular expressions: re |
|
205 for compression: gzip, zipfile, tarfile |
|
206 And there are lot more. |
|
207 |
|
208 Find more information at Python Library reference, |
|
209 ``http://docs.python.org/library/`` |
|
210 |
|
211 The modules pylab, scipy, Mayavi are not part of the standard python |
|
212 library. |
|
213 |
|
214 {{{ switch to next slide, recap }}} |
|
215 |
|
216 This brings us to the end of this tutorial, in this tutorial we |
|
217 learned running scripts from command line, learned about modules, saw |
|
218 the python standard library. |
|
219 |
|
220 {{{ switch to next slide, thank you slide }}} |
|
221 |
|
222 Thank you! |
|
223 |
|
224 .. Author: Anoop Jacob Thomas <anoop@fossee.in> |
|
225 Reviewer 1: |
|
226 Reviewer 2: |
|
227 External reviewer: |