3 - 2 + 10

"""
Explanation: Notebook-3: The Basics
In this first proper programming lesson we are going to use the Python interpreter to perform simple operations, like numeric calculations that you would normally do on a calculator and slightly more advanced operations on words. The interpreter is what reads your code and converts that into the binary instructions that the computer can understand – think of it as translator between you and the low-level components (operating system, file system, network, display, etc.) of your machine. In these notebooks the interpreter is in the background and runs when you click the 'Run' button in a code cell (in future we'll see how we can use the Python interpreter with scripts of many lines of code).  
As we progress through the excercises we'll encounter a range of new programming concepts. At this stage don't worry too much about memorizing all of them; it is through repeated used and practice that they will eventually come naturally. Instead, here we want you to try to develop a sense of what is going on and keep the concepts in mind when reading the examples... but the really important thing is to try to apply them while doing the excercises.
To help you get started, we have prepared an introductory video to aid your learning about the basic concepts in Python. Please note that by the time you have finished watching this video, you might need to re-launch binder. So if you have modified any part of your notebook, make sure to download the current version to your browser (the introductory video talks about how to do this).

How the exercises work
Lastly, a few words on the excercises; in every notebook we've tried to develop a mix of exercises and examples to show you how Python works. There are four 'levels' of exercise:

Code from Scratch: using examples already encountered in the lesson as a starting point, you will write some very simple code (1-3 lines at most) into a blank code cell. 
Supported Code: using examples and exercises already encountered in the notebook, you will fill in somes 'gaps' in the lines of code where we've replaced some critical bits with (???) in order to make it work successfully.
Broken Code: here we have deliberately broken something (sometimes, more than one thing) in the code and you will need to fix these before it will run successfully. Being able to debug code is an integral part of being a programmer, and this will also require you to have an eye for detail because tiny typos and simple sloppiness are enough to break a computer program.
Applied Geo-Example: this will be a much more advanced bit of code that will (we hope) run successfully right from the start. The point of these examples is to demonstrate a real-world application of a concept covered in the lesson and we are asking you to spend some time puzzling over the code and adding comments about what you think is going on. Being able to read someone else's code and to make sense of what is going on is another crucial skill for a programmer. 

We're not expecting you to master the fourth level at this stage; in fact, some of the examples might be challenging even after a full year of classes. However, we think it's important to try to show you where we're trying to go as well as the steps involved in how we get there. It's like trying to follow directions from someone who only tells you 'turn left', 'turn right', 'go straight' – it's a lot easier to fill in the gaps and to understand what's going on if they say "We're headed to London" first!
Simple Operations
Numeric Operations
You already saw a really simple example of calculating the mean in Notebook 1, but let's recall that you can easily use Python to like a calculator. Run the code already present in the code cells and make sure you understand the output. 
Basic Arithmetic
Addition and Subtraction
End of explanation
"""


2 * 5

10 / 5

"""
Explanation: Multiplication and Division
End of explanation
"""


print(4 * (2 - 8) + 2)
print(4 * 2 - 8 + 2)

"""
Explanation: A challenge for you!
Do you think the results of these two operations will be identical? If not, why? Decide what you think the answer is before running the code!
End of explanation
"""


(3 * 2) - 10

"""
Explanation: The results are different due to the order in which Python runs the operations. Anyway, remember the importance of parentheses in determining 'precedence' – which operations get done first.
You'll see that the code above encompases each formula in print() command on each line; this simply allows us to print out the results of both calculations when the code runs. We'll come back to this later.
End of explanation
"""


3 * (2 - 10)

"""
Explanation: is not the same as:
End of explanation
"""


2 ** 4

"""
Explanation: Exponents
Powers
If you use two asterisks instead of one then you'll be performing an exponentiation:
End of explanation
"""


2 * 2 * 2 * 2

"""
Explanation: That's the same as:
End of explanation
"""


print(2**8)           # 2-to-the-8
print(256**(1.0/8.0)) # 256-to-the-one-eighth

"""
Explanation: So 2**4 is how we get 2-to-the-power-of-4 (the same as multiplying 2 together 4 times). Hopefully this all kind of rings a bell even if you've not studied any maths in a while.
Roots
So 2**4 is 2-to-the-power-of-4, but how do we get the square root (or fourth root) of a number? Right now, with what we've taught you so far, the best way is to remember that a square root is the same as an exponent of one-half. The fourth root is an exponent of one-quarter. Etc.
End of explanation
"""


print(1/8)
print(1.0/8.0)

"""
Explanation: Floating Point numbers
Warning: the following two equations are not always the same!
End of explanation
"""


print(9/2)
print(9%2)  

"""
Explanation: Many programming languages (Python used to be one of them) treat whole numbers (1, 8) differently from floating point numbers (1.0, 8.000000000001). In those cases, we get the answer 0 to the first equation because when we use whole numbers in our calculations we got whole numbers back. So 1/8 is obviously not 0, but that's the nearest whole number to 0.125! This is what we mean about computers doing exactly what you tell them: sometimes you want 1/8 to equal 0, other times 0.125, and the computer doesn't know which answer you need unless you are very clear about what you want!
Modulo
While we're on the topic of division, how do you get the 'remainder' of 9/2 – the bit left over from the division? To get this there is a different symbol called the modulo operator which is a marked by a % sign. According in fact to the Python Documentation

The % (modulo) operator yields the remainder from the division of the first argument by the second.

Using the modulo operator will thus return the remainder:
End of explanation
"""


8%2

"""
Explanation: Just to make this clear: 2 goes into 9 exactly 4 times and then you have 1 left over. So: (4 * 2) + 1 = 9.
For division which yields no remainder the operation will return a value of 0.
End of explanation
"""


print( (2*3) ** 2 )

"""
Explanation: A challenge for you!
What do you think will be the result of this operation? Work out your answer before running the code.
End of explanation
"""


print( (2*3) ** 2 / (12 % 5) )

"""
Explanation: The answer is 36 as Python would do the multiplication inside the parenthesis first.
Now what do you think this will give you? Again, work out your answer before running the code.
End of explanation
"""


(2+4) ** 2 % (120 / ???)

"""
Explanation: In the code below replace the question marks ??? with the appropriate code to produce a remainder of 6. You may need a calculator to help you. Run the code to check your answer (you can change your answer and run the code multiple times to get the right answer).
End of explanation
"""


(30 + 2 ) / 0

"""
Explanation: Operator Precedence
The operators +, -, *, **, /, %, etc., and the parentheses are all evaluated (i.e. calculated) according to a set of rules that establish precedence, which is just a fancy way of saying: which calculations do we do first? There's a full list here but since that also lists a lot of operators we've not yet encountered it's easiest to summarise this in a table as follows:
\begin{array}{cl} \hline
Operator & Description \ \hline
(\ldots) & Parentheses \ 
* & Exponentiation \ 
+x, -x & Positive, Negative \ 
, /, \% & Multiplication, Division, Remainder \ 
+, - & Addition, Subtraction \ \hline
\end{array}
So parentheses trump everything else, then exponents (so 2**5.0/2 is not the same as 2**(5.0/2)), then positive/negative, and then multiplication/division before we finally get to addition and subtraction.
Division by Zero
Also pay attention when dividing by zero. Python won't be able to compute any value and will return an error (which is sometimes also called an exception):
End of explanation
"""


(1345 - 20 )  / ((- 3) ** 2  -  ???)

"""
Explanation: A challenge for you!
Replace the questions marks ??? in the following exercise with the appropriate code to purposufully cause a ZeroDivisionError exception (again, feel free to use a calculator and you can run the code multiple times).
End of explanation
"""


print(7 * 4)
print(7 * 4.0)

print(20 / 5)
print(20.0 / 5)

print(22 / 7)
print(22.0 / 7)
print( int(22.0/7) )

"""
Explanation: Note: the error message is Python's way of telling you what went wrong in the operation. We'll get to these in more detail in a later lesson, but you'll notice that Python always tries to tell you what it thinks went wrong and this is the starting point for all debugging. When something goes wrong in a program this error is like the first clue that puts you on the trail of the wrongdoer: sometimes one clue will lead to another, and another, and another... sometimes one clue is all you need. 
But regardless, if you ignore these clues and just put up your hand and say "It doesn't work!" then we're not going to be very impressed. We expect you to be able to explain the problem to us before we will help you with it. More on this later.
More about Ints and Floats
So we've seen some examples above of maths with integers (i.e. "whole" numbers) and maths with floats (i.e. "decimal" numbers). Both can be positive and negative (e.g. -1 or -254.32672). Programmers, being lazy, often call integers ints because it's faster and requires less typing.
Any operation involving a mix of floats and integers will always yeld a float. For example, compare the output for the code below, but note how the resulting data type varies with the operation.
End of explanation
"""


print(6 + 3)
print(6.0 + 3)

"""
Explanation: Notice that last ticky bit: we'll get to what int(...) means later, but if you remember that programmers are lazy then you might realise that it must be short for integer.
End of explanation
"""


(10 * 20)/2

"""
Explanation: The reason for this is that Python is implicitly converting (sometimes called casting) the numbers between the two different data types. This conversion doesn't happen with more complex bits of Python code, but for simple numbers Python tries to be helpful and save you the time and effort.
Note: the integer-to-float conversion might seem a bit of a pedantic distinction, but imagine if you were programming a banking application: you would definitely pay attention to all those decimals!
Some final maths questions...
Let's start with calculating the area of a triangle. Here's the equation for the area of a triangle: $$A = \frac{l_{base} * l_{height}}{2}$$
So lets work out for a triangle that has sides of length 10 and 20! If you type the maths correctly into the empty block below you should get the answer: 100
End of explanation
"""


print("I'm a string of text!")
print('Me too! *&($£(£_@~{}|?<>$)')

"""
Explanation: Now let's work out the length of the hypotenuse of a right-angle triangle with the same side lengths as above: $$l = \sqrt{x^2 + y^2}$$
You might remember this as the Pythagorean Theorem, and you should get an answer of about 22.4.
Let's move on to two last harder ones. Write a line of code to work out the area of a circle of radius 6. Here's the formula: $$A = \pi r^2$$ and you should get something around 113.1 as the area. Use 3.1412 for the constant pi.
Now work out the approximate radius of a sphere whose volume is 85. To do this, you'll need to work backwards from the formula to calculate a volume... this might seem a little rough at first, but remembering how to rearrange a formula is really helpful for computational thinking!
So what do you have to do to this formula: 
$$V = \frac{4}{3} \pi r^3$$
Here's a hint to get you started:
$$ r^3 = \frac{3}{4 \pi} V $$
Also: remember that you're going to need to work with decimal numbers, not whole numbers and write your code accordingly! You should get a final answer of about 2.7.
Note: there are a lot of different ways that you could write this formula as code and still get the right answer. Getting the right answer is 50% of the job. The remaining 50% is about doing it in a way that is elegant and easy to read... as get further into the term we'll point out how elegance and legibility (also: commenting) matter.
String Operations
OK, so that's the basics of numbers. What about text?
How long is a piece of string?
In most programming languages, text and words are called strings, which is really a fancy word to say a sequence of characters enclosed in single- or double-quotes (' or "). This might seem like stating the bleedin' obvious but this is a really, really important idea... 

"235op!u\$nlkgfd8 wp8ty fgdoy8p waklj ag9up0" 

is a string. So is: 

"If music be the food of love, play on; Give me excess of it, that, surfeiting, The appetite may sicken, and so die." (Twelfth Night, Act 1, Scene 1, 1–3) 

The thing is that computers can't automatically distinguish between Shakespeare and the work of a monkey hitting keys at random. As long as they are both marked out by single- or double-quotes then as far as the computer is concerned they are strings. So even to ask the computer how many words there in the first 3 lines of Twelfth Night means we have to 'teach' the computer what a word is by giving it rules to recognise the start or end of one, and even how to recognise the start and end of a line so that it can find the first three of them!
End of explanation
"""


print("I'm contained within double quotes. I'll be fine.")

print('I'm sourrounded by single-quotes and I contain a single-quote so there may be trouble ahead...')

"""
Explanation: Note: As before, we'll be using the print() command on many lines of code; that is just a way to tell the Python interpreter to output somthing for us to see.
Single- or Double-Quotes?
Although you can technically use either type of quote (' or "), it is generally better to use double-quotes as a way to prevent errors if a single-quote is contained in your string:
End of explanation
"""


print('I\'m using the backslash.')
print('I\'m also using the backslash \'\\\' to escape the error normally caused by having single-quotes.')

"""
Explanation: Notice the helpful error message after running the code above? We'll come back to how to read errors like these in more detail in the next notebook, but again Python is giving us hints about where we might have made a mistake.
Escape Club
What do you do if your string contains double-quotes and single-quotes? That's where the 'backslash' (\, a kind of 'reverse division' symbol) comes in handy. The backslash is how we 'escape' characters so that we can do 'special' things with them when they should normally do something else.
In the example below, the backslash in front of the apostrophe in "I'm" says "Don't treat this as 'normal' single-quote that means the end of the string, treat it as a literal single-quote in the middle of a longer string marked out by single-quotes.
End of explanation
"""


print('I\'m also using the backslash \'\\' to escape the error normally caused by having single-quotes.')

"""
Explanation: Let's look at this a little more closely:
* The first line is easy: the backslash in front of the single-quote in "I'm" allows us to use single-quotes to mark the start and end of the string. This is a silly example since we could also have written "I'm using the backslash" but you get the point.
* The second line gets a little more complicated: you'll see that we've now escaped three single-quotes (there are three occurences of "\'"). But what's happening with "\\"? Well, we need an extra backslash in front of the backslash so that the computer knows to print a literal backslash (we are 'escaping' the normal function of a backslash to escape the character immediately after it) instead of reading it as escaping the one in front of the single-quote.
That's pretty weird, but just to show you what's happening here it is without that extra backslash:
End of explanation
"""


print("If music be the food of love, play on;\n Give me excess of it, that, surfeiting ,\n The appetite may sicken, and so die.")

"""
Explanation: If you run the code above, you'll see another error! Also notice that in the two lines of code, in the first the whole line is in one colour (meaning the computer can see that it's all one string), but in the broken example right before this the text changes colour once we get to "to escape the error..." (meaning that the computer doesn't see it all as one string).
The escape symbol crops up in a lot of other circumstances. For example, what if we wanted to tell Python that a string contains a newline (i.e. that the string is split across one or more lines, like our Shakespeare quote above should be)? 
Remember that programmers are always lazy when given half a chance and so they figured out that the easiest way to mark a newline was \n. They used 'n' because it is fairly easy to remember that that means 'newline', and the backslash 'escapes' us from the simple world where an 'n' is the letter 'n' into the computer's world where 'n' is 'n', but \n is a newline:
End of explanation
"""


print("2016")
print(2016)

"""
Explanation: See how that wraps the text on the \n? Also note that the computer is printing exactly what we told it to do: I kept a space between the \n and the start of the next line. If you squint, then you can see that lines 2 and 3 are indented by the width of one space character. There's also an extra space after 'surfeiting' before the comma.
Why details matters
We say this a lot later too, but you might as well start learning this fact now: spaces in a string matter. To a computer " A string" and "A string" are not the same. Notice that there is a single space in front of the 'A'. As a human being we tend to just skip over that space (especially if it's hard to see), but to a computer one string starts with 'A' and the other with ' ', so they are completely different.
Further, numbers and strings are not the interachangeable: "2016" is not the same as 2016. The first is a string that happens to contain the characters 2, 0, 1, and 6. The second is an integer number one larger than 2015.
End of explanation
"""


2015 + 1

"2015" + 1

"""
Explanation: As you can see from running the code above, it's a bit annoying that they look the same when we print them. But if you run the next lines of code (after thinking about what they might do), you'll see how Python tries to be helpful with its errors:
End of explanation
"""


print("""Hi there,
this time, 
I won't need those annoying newline characters.
I also don't have problems with "quotes" or 'quotes'! """)

"""
Explanation: See how the first line of code prints 2016, but the second line of code (which tries to add together a string "2015" and the number 1) gives you an error that lazily tells you about a problem with str (i.e. string) and int (i.e. integer) 'concatentation'. More on concatenation in a minute.
Advanced laziness
Obviously, having a lot of \n markers would be hard to read and a potential problem if you wanted to copy and paste the text into a different application. If you have a long block of text then you can avoid the whole issue by putting your text inside triple-quotes:
End of explanation
"""


print("String1" + "String2")
print("Hey, looks like" + " I'm " + "adding "+ "6" +" strings" + " together")

"""
Explanation: Adding with strings (concatenation)
As with numbers, there are many things that you can do with strings. The simplest, however, is like addition (which is why it uses a +): when you add strings together you get a new, longer string that contains the characters of the original strings. This is usually called concatenation:
End of explanation
"""


print("This is code " ??? " camp's notebook is "  ??? " number " + "2.")

"""
Explanation: So just like you would do to add two numbers together, we can add "String1" and "String2" together to get "String1String2". But notice that the + operator doesn't insert whitespace (i.e. a ' ' character) or anything else. It just sticks the two strings together exactly as they are.
And just like we can add together a whole set of numbers, we can add together a whole set of strings as in the second line beginning "Hey, looks like..."
A challenge for you!
Replace the questions marks "???"  in the following exercise with the appropriate code to make it work
End of explanation
"""


print("I like Python a lot" + "!" * 3)
print("Foo " * 25)

"""
Explanation: Multiplication
If you use the multiplication operator (*) on a string then you will multiply the string by the value of the multiplier.
End of explanation
"""


20 * '5'

"""
Explanation: A challenge for you!
What do you think will be the output of this code? (Work out your answer before running the code)
End of explanation
"""


print("5" * "2")

"""
Explanation: Now, why do you think the next example below doesn't work? (Read the error output if you're not sure what's going on.)
End of explanation
"""


result = -2 * 10

"""
Explanation: What is a variable?

So far, everything we've done was about performing some kind of calculation on an integer, float, or string, and then showing the result. Given that a lot of programming doesn't involve solving everything in one easy line, how do you save an answer so that you can re-use it later? Let's start with the first true programming concept: the   variable.
If you have studied other programming languages before then the concept of the variable will be so familiar to you that it's hard to remember even having to learn it! Some people think of a variable simply as "a box" that contains values that we want to store and retrieve in the future. However, we think it might be more useful to think of a variable as the label of a box in which we put something: for programmers, the label is how we remember what we put in the box and where we put it. 
Let me try to explain: if you watched the introductory videos in the previous notebook, then you'll remember that the computer stores 'information' in lots of places (in memory, on the hard drive, etc.), but it doesn't use an addressing system that you or I would be able to read. Instead, it will use a long, complicated number that tells the computer "Go look in this place for what to do when the mouse is clicked" or "Go look what to do when someone asks you to add together 1 and 5". In the same way that Python translates between what we humans can deal with and what the computer can deal with, it also translates between the 'labels' that we use to refer to different boxes storing different things and how the computer finds what we actually put there.
Here's an example:
End of explanation
"""


result = -2 * 10
print("I'm wasting space...")
print(result)

"""
Explanation: Hmmmm, nothing printed out this time... 
That's because this time we gave Python a bax with the label "result" in which to put the result of multiplying -2 and 10.
End of explanation
"""


# First, we need to check the data type of our variable using a function called "type"
type(result)
# Rewrite the existing variable or put it as a new variable 
result = float(result) # or result_float = float(result_float)
type(result) 

"""
Explanation: Can you check the data type of your variable result and switch it to float?
End of explanation
"""


myFirstVariable = 1 * 5
print(myFirstVariable)

mySecondVariable = myFirstVariable
print(mySecondVariable)

"""
Explanation: Check it out! We assigned the outcome of -2 * 10 to a variable called result; then we did something else (printed out a string); and then we printed out the value of the variable and the computer remembered! 
This video may help you to further understand the concept of a 'variable':
<a href="http://www.youtube.com/watch?feature=player_embedded&v=_sVtcPgHAjI" target="_blank"><img src="http://img.youtube.com/vi/_sVtcPgHAjI/0.jpg" 
alt="IMAGE ALT TEXT HERE" width="480" height="360" border="10" /></a>
Copying variables
And variables can be copied using the = operator in the same way that the result of the maths operation above could be assigned to a new variable called result.
End of explanation
"""


myFirstVariable = 2
print(myFirstVariable)
print(mySecondVariable)

"""
Explanation: Cool, both variables have the same value! We assigned the result of 1 * 5 to a variable named myFirstVariable and then we assigned this value to a second variable called mySecondVariable. 
But why is this called assignment (or, in plain English, copying)? Well what happens when I change the first variable myFirstVariable? Will the second change as well?
End of explanation
"""


cheers ??? name ??? " is awesome!"
print(cheers)

cheers = name + " is awesome!"
print(cheers)

"""
Explanation: Whoa! mySecondVariable didn't change and still remembers what we assigned to in the first time. 
Basically, we took the myFirstVariable label and attached it to a different box.
As the Python Programming Wikibook explains, when you assign a variable you are just pointing this variable to an object (a value) which is stored somewhere in the memory.
Python variables are a kind of 'label' (as the YouTube video above illustrates – watch it!). So when assigning new values to already declared variables (i.e. variables that already exist in your code) you are not overwriting the old values but simply "moving" the label from one value to another.
That's why in Python variables have a name, a data-type and a value.
|       Name      | Data Type | Value |
|:---------------:|:---------:|:-----:|
| myFirstVariable | integer   | 1     |
A challenge for you!
In the code cell below:
a) define a variable called "name" and assign it a value of your choice, then 
b) print it with the "print" command
For example:
name = "Peter"
print(name)
Replace the questions marks ??? in the following lines of code with the appropriate code to make it work (i.e. not produce an error).
End of explanation
"""


famous_geographer = "Mercator"
print(famous_geographer)

"""
Explanation: Naming variables
How do you choose a variable name (i.e. label) in Python?  
Here's a short list of the conventions:
* names may contain letters and/or numbers (e.g. myVar2)
* names cannot begin with a number (e.g. 2myVar)
* names may contain an underscore ("_") (e.g. my_var_2)
* names can be of any length (e.g. m2 or mySecondVariableIsReallyLong)
* you cannot use Python keywords (e.g. print)
So this block of code below will run:
End of explanation
"""


1st_geographic_projection =  """ Mercator's most famous Geographic Projection 
is a cylindrical map projection 
that retains the ability
to ability to represent lines of constant course (loxodromes)"""

print(1st_geographic_projection)

"""
Explanation: But this block of code will not:
End of explanation
"""


this_var = "Mercator"
This_var = "Galileo"

print(this_var)
print(This_var)

"""
Explanation: Notice how the notebook has coloured the text so that the '1' in what we wanted to make the variable name stands out? Again, that's Python trying to help us figure out what is going wrong, but it requires that you look closely at the output of the error message.
A final warning
Remember that we said the string " Some text" and the string "Some text" are different because the space at the start of the string changes everything? The same sort of strict checking is true for variables: in short, Python is case-sensitive! 
This means that this_var and This_var are two different variables and can refer to two different boxes:
End of explanation
"""


old_satellite = 'Sputnik 1'
old_satellite_description = " was the first artificial Earth satellite, launched from the Soviet Union on the 4th of October, 1957."
print("Здравствуйте! My name is " + old_satellite)
print(old_satellite + old_satellite_description)

"""
Explanation: As for many issues related to Python's style, it is good practice to always refer to the offical PEP 8 -- Style Guide for Python Code
For more examples of Python variables check out also OpenTechSchool's intro to Python
Code (general excercises)
Now that we've had a taste of the fantastic Python programming world, let's solidify our newly acquired skills with a final round of excercises.
Code from scratch
Exercise 1
Look at the following example (and its output):
End of explanation
"""


new_satellite = 'Landsat'
print(new_satellite)

print("The new satellite is " + new_satellite + " and the old satellite is " + old_satellite)

"""
Explanation: Similar to the example above, in the code cell below:
1. define a variable named new_satellite with value landsat
2. try to print its name
3. then try to concatenate its name with another variable description of your choice, 
4. and print them.
End of explanation
"""


pr???nt("Hello there " + ???(new_satellite) )

print("Hello there " + new_satellite + " 8" )

"""
Explanation: Supported code
Replace the questions marks ???  in the following exercise with the appropriate code to make it work
Exercise 2
Landsat is a bit generic, the correct name is Landsat 8. How would you put together these two different Data Types? Remember what we've seen about casting? Edit the code below to make it work.
End of explanation
"""


diameter_cm = 58
cm2inches = 0.393700787
diameter_inches = diameter_cm ??? cm2inches
print(diameter_inches)

diameter_cm = 58
cm2inches = 0.393700787
diameter_inches = diameter_cm * cm2inches
print(diameter_inches)

"""
Explanation: Excercise 3
According to its Wikipedia page Sputnik 1 was a 58 cm diameter polished metal sphere. If a cm = 0.393700787 inches what was its diameter in inches? Edit the code below to make it work.
End of explanation
"""


import math
PI = math.pi

radius_cm = diameter_cm/2
volume =  (4/3) ??? PI ??? (radius_cm  ??? 3 )
print(volume)

import math
PI = math.pi

radius_cm = diameter_cm/2
volume =  (4/3) * PI * (radius_cm  ** 3 )
print(volume)

"""
Explanation: Exercise 4
Wat was its volume (in cubic cm)? # NOTE: the first line below we are "importing" the math module and assigning to a variable PI the value of pi (3.14...). Edit the code to make it work.
End of explanation
"""


print(new_satellite + "has a Near Infrared (NI), \
which band captures light in the wavelength from "+
      770 +
      " to " +
      900 +
      " nanometers." )

# The error message indicates a type error, as we can only concatenate string
# The code should work by including "" to the numbers

print(new_satellite + " has a Near Infrared (NI), \
which band captures light in the wavelength from "+
      "770" +
      " to " +
      "900" +
      " nanometers." )

"""
Explanation: Broken code
mmh..something's broken in the following line of code; can you spot the error(s)? Hint: remember what we said about different data types...
End of explanation
"""


# King's College coordinates
# What format are they in? Does it seem appropriate?
longitude = -0.11596798896789551
latitude = 51.51130657591914

#cast the floats to strings
??? = str(longitude)
lat = str(???)

# King's College marker
KCL_position = "https://www.openstreetmap.org/?mlat="+lat+"8&mlon="+lon+"#map=15/"+lat+"/"+lon
          
print(KCL_position)

# King's College coordinates
# What format are they in? Does it seem appropriate?
longitude = -0.11596798896789551
latitude = 51.51130657591914

#cast the floats to strings
lon = str(longitude)
lat = str(latitude)

# King's College marker
KCL_position = "https://www.openstreetmap.org/?mlat="+lat+"8&mlon="+lon+"#map=15/"+lat+"/"+lon
          
print(KCL_position)

"""
Explanation: Code (Applied Geo-example)
In this excercise you'll dip a toe in the wonderful world of web maps!
We are going to create a geographic marker (a pin on the map!) on top of OpenStreetMap (OSM) to visualise King's College location.
To do so we'll have to create a string representing a web URL (that's the address you type in your browser when your surf the web) pointing to OSM website.
Now, as you can see there are two variables containing King's College Longitute/Latitude coordinate position. You will need to use them within the variable KCL_position. Unfortunately they are in the wrong data type! Also, there might be something missing in the code.
HINT: To convert (cast) a float to a string use the str() function (we haven't talked about functions yet, but see if you can work it out). You'll also need to think about how to concatenate strings? 
Replace the ??? in the code below to make it work.
End of explanation
"""


