1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
# Introductory Scientific Computing with Python
This is an entirely hands-on workshop. At the end of this workshop, attendees
should be able to use the basic tools and libraries for Python-based
scientific computing. We imagine that an undergraduate/graduate
engineering/science student would be able to *start* doing their basic
computing tasks using Python.
The course features multiple simple quizzes that students take online. Based
on the performance in these quizzes students are given grades and a
certificate.
## Intended audience and pre-requisites
This course is designed to be taken by folks who do not have any programming
experience. The students should be comfortable using a computer and editing
text files.
Prior experience with Scilab/Matlab/octave or similar tools would be useful
but not necessary.
For those of you who do not have much experience using a keyboard to type or do
not know touch typing, it would be a good idea to practice typing using online
typing tutors. Here is a good one:
https://www.speedtypingonline.com/typing-tutor
Just practice and go through the default lessons and learn the basic keys. The
more you practice the better you become. If you are not good at typing quickly,
you might benefit from a few hours of practice. Try to log two to four hours on
this and you will find that your typing speed improves significantly.
## Software and hardware requirements:
A laptop or reasonably configured desktop is recommended since this will be a
hands-on session.
The following packages need to be installed:
- Python (2.x or 3.x)
- IPython/Jupyter
- NumPy
- SciPy
- Matplotlib
- Optionally install Mayavi.
On Linux, Windows and Mac OS X it is easiest to install Python and many other
useful packages by installing Anaconda. Download the Anaconda Python distribution
for your OS and architecture from here: https://www.anaconda.com/products/individual. The instructions to install are available here https://docs.anaconda.com/anaconda/install/
You can use Anaconda or Conda along with the Spyder editor or the VSCode editor.
On many Linux distributions, these packages are easy to install.
## Detailed outline
The session is entirely hands-on. We focus on common tasks and introduce the
Python language in the context of these common tasks. Here is an outline
of what is covered:
- Introduction to Python and some preliminaries.
- Getting started with IPython and creating basic plots with `pylab`.
- Using IPython effectively, reading documentation interactively.
- Basic plots.
- Decorating plots with labels, legends, annotation, and titles.
- Multiple plots and separate figures.
- Saving plots.
- Saving Python scripts and running them using IPython and Python.
- Using `%hist` and `%save`
- Creating new Python scripts on an editor.
- Running scripts in IPython using `%run`.
- Running scripts from the terminal with `python`.
- Creating and using lists, list slicing, list operations.
- Creating data and storing them in lists.
- Plotting data in lists.
- Initializing and accessing list elements with indexing
- List slicing, striding, and list operations
- Looping over a list with `for`.
- Defining functions in Python.
- Functions accepting arguments and returning values.
- Timing operations using IPython's `%timeit` and `%time` magic.
- NumPy array basics:
- Importing numpy.
- Basic array attributes and operations.
- 1-D and multi-dimensional arrays.
- Array slicing and striding.
- Other array creation functions.
- Basic array math.
- Reading data files with `loadtxt`.
- Exercise on plotting data from a file.
- More on NumPy.
- Creating matrices using numpy arrays.
- Special kinds of matrices, `ones`, `identity` etc.
- Accessing elements, accessing rows and columns.
- Setting elements, setting rows and columns.
- Multi-dimensional slicing and striding.
- Elementary image processing using numpy arrays.
- Reading an image and matrix as a numpy array.
- Viewing an image/matrix.
- Basic cropping, sub-sampling images.
- More matrix operations.
- Transposition.
- Elementwise addition/multiplication.
- Matrix multiplication with `numpy.dot`.
- Inverse, determinant, sum of elements.
- Computing norms, eigenvalues, and eigenvectors.
- Computing the singular value decomposition.
- Performing a least squares fit for some experimental data.
- Read data from a file.
- Perform a least square fit from first principles.
- Introduction to random number generation with `numpy.random`.
- Introduction to Jupyter/IPython notebooks.
- Starting up the notebook.
- Using `%pylab` and `%matplotlib`.
- A sample notebook with a demonstration of images, equations, code, and
simple widgets.
The above are covered first, additional material is also made available to
users that they can see at their leisure. These are optional but students are
suggested to go over the material on their own.
- Introduction to the SciPy package. (52 minutes)
- Solving a system of linear equations.
- Finding the roots of a polynomial using `numpy.roots`.
- Finding the roots of non-polynomial equations using scipy's `fsolve`.
- Numerical integration of Ordinary Differential Equations (ODES).
- Example of a 1D ODE.
- Example of a coupled 2D ODE or a second order DE.
- Using scipy's `fft` module for basic signal processing
- Finding the FFT and inverse FFT.
- Simple noise filtering using `scipy.signal`.
- Exercises: (65 minutes)
- We solve 5 different problems using the tools we have learned.
- Users are given time to solve the problem.
- The solution is shown and explained before the next problem.
- Simple 3D plots with Mayavi's `mayavi.mlab`. (50 minutes)
- Introduction to Mayavi.
- Getting started with `mlab`
- Using `mlab` in a console and in an IPython notebook.
- Basic plotting with Mayavi
- 0D data, 1D data, 2D data, and 3D data.
- Simple scalar and vector plots.
- Utility functions to annotate the plot and save images.
Session wise slide breakup:
1. intro.pdf
2. prelims.pdf
3. ipython_plotting.pdf
4. saving_scripts.pdf
5. lists_arrays.pdf
6. numpy.pdf
7. more_numpy.pdf
8. scipy.pdf
9. exercises.pdf
10. notebook.pdf
11. mlab.pdf
|
