Skip to content
Snippets Groups Projects
Commit 36501145 authored by Paul McCarthy's avatar Paul McCarthy :mountain_bicyclist:
Browse files

ENH: Qijia+Tom's intro to programming notebook

parent 54028b9b
No related branches found
No related tags found
1 merge request!32ENH: Qijia+Tom's intro to programming notebook
Hide whitespace changes
Inline Side-by-side
getting_started/README.md
+ 4
− 0
View file @ 36501145
......@@ -12,6 +12,10 @@ then you might want to check out the `advanced_programming` or `applications`
folders.
The **Introduction to programming** (`intro_to_programming.ipynb`) practical
is a useful place to start if you have zero or little programming experience.
The **Overview** practical is a whirlwind overview of the Python language,
incorporating bits and pieces from the other practicals. Feel free to start
there, or to start from the **Python basics** practical.
......
getting_started/intro_to_programming.ipynb 0 → 100644
+ 372
− 0
View file @ 36501145
%% Cell type:markdown id: tags:
# Introduction to programming
**Qijia Shen and Tom Okell, Jan 2023**
***Acknowledgements: Many thanks to Emily Santis Okell for providing very useful feedback.***
*Target audience: people with no or little programming experience*
%% Cell type:markdown id: tags:
## Where am I?
You are looking at a jupyter notebook. This a convenient way of programming in the python language from within a web browser, mixed with with some text like this! You should have launched this page from a terminal using:
`cd directory/containing/this/file/`
`fslpython -m notebook`
Then clicking on `intro_to_programming.ipynb`
Note that you can run python in other ways too, but this is convenient for now!
%% Cell type:markdown id: tags:
## What are we doing here?
Below are some very simple examples of programming concepts. Here we are using the python programming language. Please don't worry if the exact way things are written is a little unclear: the following sessions will go into a lot more detail about exactly how you write code in python. For now, we are just focussing on the concepts!
%% Cell type:markdown id: tags:
## Variables
A variable is a "container" for some information. We can assign a value to a variable using the equals "=" sign:
%% Cell type:code id: tags:
``` python
# This is a block of python code that you can execute within this browser window
# by clicking on it and then hitting shift+enter. Anything after a hash (#) is a
# comment and is ignored when the code is run. You can modify any of the code
# below and re-run it with shift+enter to see what happens! Let's define a
# variable called "a" that we give the value 3:
a = 3
# We can change the value assigned to the variable "a" at any time:
a = 4
# We can define a variable to contain a character, like this:
a = 's'
# Or a set of characters, known as a string:
a = 'hello'
# We can define another variable, b, and give it the same value as a:
b = a
# If a is a number, we can do some simple maths:
# Here b is given a value one more than a, and c is given a value twice
# the size of a (note that * is used for "multiply" in python):
a = 3
b = a + 1
c = 2 * a
# If you want to show the value of a variable, you can do it like this:
print('a has the value',a)
print('b has the value',b)
print('c has the value',c)
# Note that 'print' here means 'print to the screen', not 'print to a printer'!
# The output should appear just below this block after you hit shift+enter:
```
%% Cell type:markdown id: tags:
## Flow control: the "if" statement
We can control the 'flow' (i.e. which bits of code get executed and which don't and the order in which they happen) of the program we write using a number of simple statements, like the "if" statement:
%% Cell type:code id: tags:
``` python
# We can do something based on the value of a variable
# For example, if the variable a is a number larger than 10,
# then say "big!", otherwise say "small"
a = 11
if a > 10:
print('big!')
else:
print('small!')
# You can try changing the value of a above the "if" statement to make sure this
# works as expected!
```
%% Cell type:markdown id: tags:
## Flow control: a "for" loop
For repetitive tasks, loops such as the "for" loop are extremely useful:
%% Cell type:code id: tags:
``` python
# In this case we want to repeat the statements below the "for" many times. Each
# time, the value stored in the variable "a" changes, starting from 1 and ending
# before 10 (so 9 is the last value of a in this case). Here we simply "print"
# the value of a to the screen each time we go around the loop.
for a in range(1,10):
print(a)
```
%% Cell type:markdown id: tags:
## Functions
Writing lots of code as one huge file can get rather messy! You will often find that you want to perform some specific task multiple times within the same bit of code, so it can be very useful to define a "function", which takes some inputs, performs some operations and then returns some output. Here's a very simple example:
%% Cell type:code id: tags:
``` python
# Define a function that returns the number passed into it squared:
def square_my_number(a):
a_squared = a * a
return a_squared
# Note that in the above code the variable "a" is only used internally
# within the function and just represents whatever number has been passed
# into the function as its input. That number might be stored in another variable
# with a different name in the code that calls the function, as you will see below.
# In other words, you don't have to only use this function with a variable
# called "a"!
# We can now use this function however many times we wish:
n = 3
# Here we "call" the "square_my_number" function, passing in the value of n as
# input. The function returns n squared and this value is stored in a new
# variable which we've called n_squared here:
n_squared = square_my_number(n)
print('n is',n,'and n_squared is',n_squared)
# Do the same thing again for a different variable, m:
m = 4
m_squared = square_my_number(m)
print('m is',m,'and m_squared is',m_squared)
# Although this is a very simple example, hopefully you can see that if
# square_my_number was a much more complicated procedure, it would be a lot
# easier and neater to define the function and then call it once using n and
# once using m, rather than copying all of the code applied to n and writing it
# again to apply to m.
```
%% Cell type:markdown id: tags:
## Using code from packages
There are tonnes of extremely useful bits of code which have been conveniently packaged up for you! Don't worry about the details here, but as an example we "import" the predefined package called "numpy", which can do all sorts of clever bits of maths:
%% Cell type:code id: tags:
``` python
# Import the numpy package so we can use it in the code below:
import numpy as np
# Define a variable called "data" which contains a set or "array" of numbers
# using numpy
data = np.array([10, 8, 12, 14, 7, 6, 11])
# Numpy can do lots of cool things, including the one dimensional Fast Fourier
# Transform (FFT)! Here the Fourier transform of the numbers in the array "data"
# are calculated and then stored in a new variable called "ftdata":
ftdata = np.fft.fft(data)
# Note that we could have defined our own function to perform the Fourier
# Transform if we wanted to, but it's very convenient that a lot of these
# complicated algorithms have already been implemented in a fast and efficient
# way.
```
%% Cell type:markdown id: tags:
## If you have time, let's use programming to perform a boring, repetitive task...
Say we want to input ***1~100*** into a text (***.txt***) file, but we don't want repetitively press the keyboard hundreds of times (and probably make a mistake...), here's what we could do!
%% Cell type:markdown id: tags:
Let's start with a simple of example of writing a single number into a text file:
Here we want to have a text file called *'temp.txt'* in the current directory, and the content of the file is just single character *1*
%% Cell type:code id: tags:
``` python
# Define the number to write and store in a variable, a
a = 1
# Open the file to allow us to write into it
f = open('temp.txt','w')
# Write the value in variable a to the file
# Don't worry about the exact form of the code below - you'll learn more about
# this later!
f.write(f'{a}' + '\n')
# Close the file
f.close()
```
%% Cell type:markdown id: tags:
## Now let's use a for loop to write the numbers 1~100 into the file
%% Cell type:code id: tags:
``` python
# Open the file
f = open('temp.txt','w')
# Loop through the values we want using variable "a"
# Remember the way "range" works here is to go up to but
# not including the number you specify, so if we want to stop
# at 100, we use range(1,101)
for a in range(1,101):
# Write the value into the file
f.write(f'{a}' + '\n')
# Close the file
f.close()
```
%% Cell type:markdown id: tags:
You can check the contents of that file in your terminal by running:
`cat temp.txt`
%% Cell type:markdown id: tags:
## Now imagine we want to write ***1~100*** but exclude number 6
We can achieve this fairly easily using a simple if statement:
%% Cell type:code id: tags:
``` python
# Open file
f = open('temp.txt','w')
# Loop through the values we want
for a in range(1,101):
# Here we can use an "if" statement to only write the number into the
# file if it is not 6. Note that in python "!=" means "not equal to"
# so the code below only executes if a is not 6
if a != 6:
# Write the value into the file
f.write(f'{a}' + '\n')
# Close the file
f.close()
```
%% Cell type:markdown id: tags:
Again, you can check the contents of that file in your terminal by running:
`cat temp.txt`
%% Cell type:markdown id: tags:
## Done!
Well done on making it this far! As mentioned above, don't worry too much if the exact way the code is written wasn't totally clear. The following sessions will discuss in more detail exactly how to write code in python, but hopefully this has given you an idea of the kinds of basic structures used in programming that you will use in future sessions.
%% Cell type:code id: tags:
``` python
```
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment