## Jupyter Snippet P4M 01

Jupyter Snippet P4M 01

All of these python notebooks are available at https://gitlab.erc.monash.edu.au/andrease/Python4Maths.git

# Getting started

Python can be used like a calculator. Simply type in expressions to get them evaluated.

## Basic syntax for statements

The basic rules for writing simple statments and expressions in Python are:

- No spaces or tab characters allowed at the start of a statement: Indentation plays a special role in Python (see the section on control statements). For now simply ensure that all statements start at the beginning of the line.
- The ‘#’ character indicates that the rest of the line is a comment
- Statements finish at the end of the line:
- Except when there is an open bracket or paranthesis:

```
1+2
+3 #illegal continuation of the sum
(1+2
+ 3) # perfectly OK even with spaces
```

- A single backslash at the end of the line can also be used to indicate that a statement is still incomplete

```
1 + \
2 + 3 # this is also OK
```

The jupyter notebook system for writting Python intersperses text (like this) with Python statements. Try typing something into the cell (box) below and press the ‘Run’ button above to execute it. We will discuss operators that can be used in such operations further below, but for numbers these are mostly fairly obvious.

```
1 + 2 * 3
```

```
7
```

Python has extensive help built in. You can execute `help()`

for an overview or `help(x)`

for any library, object or type `x`

. Try using `help("topics")`

to get a list of help pages built into the help system.

```
help("topics")
```

```
Here is a list of available topics. Enter any topic name to get more help.
ASSERTION DELETION LOOPING SHIFTING
ASSIGNMENT DICTIONARIES MAPPINGMETHODS SLICINGS
ATTRIBUTEMETHODS DICTIONARYLITERALS MAPPINGS SPECIALATTRIBUTES
ATTRIBUTES DYNAMICFEATURES METHODS SPECIALIDENTIFIERS
AUGMENTEDASSIGNMENT ELLIPSIS MODULES SPECIALMETHODS
BASICMETHODS EXCEPTIONS NAMESPACES STRINGMETHODS
BINARY EXECUTION NONE STRINGS
BITWISE EXPRESSIONS NUMBERMETHODS SUBSCRIPTS
BOOLEAN FLOAT NUMBERS TRACEBACKS
CALLABLEMETHODS FORMATTING OBJECTS TRUTHVALUE
CALLS FRAMEOBJECTS OPERATORS TUPLELITERALS
CLASSES FRAMES PACKAGES TUPLES
CODEOBJECTS FUNCTIONS POWER TYPEOBJECTS
COMPARISON IDENTIFIERS PRECEDENCE TYPES
COMPLEX IMPORTING PRIVATENAMES UNARY
CONDITIONAL INTEGER RETURNING UNICODE
CONTEXTMANAGERS LISTLITERALS SCOPING
CONVERSIONS LISTS SEQUENCEMETHODS
DEBUGGING LITERALS SEQUENCES
```

## Variables & Values

A name that is used to denote something or a value is called a variable. In python, variables can be declared and values can be assigned to it as follows,

```
x = 2 # anything after a '#' is a comment
y = 5
xy = 'Hey'
print(x+y, xy) # not really necessary as the last value in a bit of code is displayed by default
```

```
7 Hey
```

Multiple variables can be assigned with the same value.

```
x = y = 1
print(x,y)
```

```
1 1
```

The basic types build into Python include `float`

(floating point numbers), `int`

(integers), `str`

(unicode character strings) and `bool`

(boolean). Some examples of each:

```
2.0 # a simple floating point number
1e100 # a googol as floating point number
-1234567890 # an integer
True or False # the two possible boolean values
'This is a string'
"It's another string"
print("""Triple quotes (also with '''), allow strings to break over multiple lines.
Alternatively \n is a newline character (\t for tab, \\ is a single backslash)""")
```

```
Triple quotes (also with '''), allow strings to break over multiple lines.
Alternatively
is a newline character ( for tab, \ is a single backslash)
```

Python also has complex numbers that can be written as follows. Note that the brackets are required.

```
complex(1,2)
(1.0+2j) # the same number as above
```

```
(1+2j)
```

## Operators

### Arithmetic Operators

Symbol | Task Performed |
---|---|

+ | Addition |

- | Subtraction |

/ | Division |

// | Integer division |

% | Modulus (remainder) |

* | Multiplication |

** | Exponentiation (power) |

As expected these operations generally promote to the most general type of any of the numbers involved i.e. int -> float -> complex.

```
1+2.0
```

```
3.0
```

```
3-1
```

```
2
```

```
2 * (3+0j) * 1.0
```

```
(6+0j)
```

```
3/4
```

```
0.75
```

In many languages (and older versions of python) 1/2 = 0 (truncated division). In Python 3 this behaviour is captured by a separate operator that rounds down: (ie a // b$=\lfloor \frac{a}{b}\rfloor$)

```
3//4.0
```

```
0.0
```

```
15%10
```

```
5
```

Python natively allows (nearly) infinite length integers while floating point numbers are double precision numbers:

```
11**300
```

```
2617010996188399907017032528972038342491649416953000260240805955827972056685382434497090341496787032585738884786745286700473999847280664191731008874811751310888591786111994678208920175143911761181424495660877950654145066969036252669735483098936884016471326487403792787648506879212630637101259246005701084327338001
```

```
11.0**300
```

```
---------------------------------------------------------------------------
OverflowError Traceback (most recent call last)
<ipython-input-14-b61ab01789ad> in <module>
----> 1 11.0**300
OverflowError: (34, 'Numerical result out of range')
```

### Relational Operators

Symbol | Task Performed |
---|---|

== | True, if it is equal |

!= | True, if not equal to |

< | less than |

> | greater than |

<= | less than or equal to |

>= | greater than or equal to |

Note the difference between `==`

(equality test) and `=`

(assignment)

```
z = 2
z == 2
```

```
True
```

```
z > 2
```

```
False
```

Comparisons can also be chained in the mathematically obvious way. The following will work as expected in Python (but not in other languages like C/C++):

```
0.5 < z <= 1
```

```
False
```

### Boolean and Bitwise Operators

Operator | Meaning | | | Symbol | Task Performed |
---|---|---|---|---|

`and` |
Logical and | | | & | Bitwise And |

`or` |
Logical or | | | $\mid$ | Bitwise OR |

`not` |
Not | | | ~ | Negate |

| | ^ | Exclusive or | ||

| | » | Right shift | ||

| | « | Left shift |

```
a = 2 #binary: 10
b = 3 #binary: 11
print('a & b =',a & b,"=",bin(a&b))
print('a | b =',a | b,"=",bin(a|b))
print('a ^ b =',a ^ b,"=",bin(a^b))
print('b << a =',b<<a,"=",bin(b<<a))
```

```
a & b = 2 = 0b10
a | b = 3 = 0b11
a ^ b = 1 = 0b1
b << a = 12 = 0b1100
```

```
print( not (True and False), "==", not True or not False)
```

```
True == True
```

### Assignment operators

The binary operators can be combined with assignment to modify a variable value. For example:

```
x = 1
x += 2 # add 2 to x
print("x is",x)
x <<= 2 # left shift by 2 (equivalent to x *= 4)
print('x is',x)
x **= 2 # x := x^2
print('x is',x)
```

```
x is 3
x is 12
x is 144
```

# Built-in Functions

Python comes with a wide range of functions. However many of these are part of stanard libraries like the `math`

library rather than built-in.

## Converting values

Conversion from hexadecimal to decimal is done by adding prefix **0x** to the hexadecimal value or vice versa by using built in `hex( )`

, Octal to decimal by adding prefix **0** to the octal value or vice versa by using built in function `oct( )`

.

```
hex(171) # hexadecmial value as string
```

```
'0xab'
```

```
0xAB
```

```
171
```

`int( )`

converts a number to an integer. This can be a single floating point number, integer or a string. For strings the base can optionally be specified:

```
print(int(7.7), int('111',2),int('7'))
```

```
7 7 7
```

Similarly, the function `str( )`

can be used to convert almost anything to a string

```
print(str(True),str(1.2345678),str(-2))
```

```
True 1.2345678 -2
```

## Mathematical functions

Mathematical functions include the usual suspects like logarithms, trigonometric fuctions, the constant $\pi$ and so on.

```
import math
math.sin(math.pi/2)
from math import * # avoid having to put a math. in front of every mathematical function
sin(pi/2) # equivalent to the statement above
```

```
1.0
```

## Simplifying Arithmetic Operations

`round( )`

function rounds the input value to a specified number of places or to the nearest integer.

```
print( round(5.6231) )
print( round(4.55892, 2) )
```

```
6
4.56
```

`abs( )`

provides the absolute value of any number (including the magnitude of a complex number).

```
c =complex('5+2j')
print("|5+2i| =", abs(c) , "\t |-5| =", abs(-5) )
```

```
|5+2i| = 5.385164807134504 |-5| = 5
```

`divmod(x,y)`

outputs the quotient and the remainder in a tuple (you will be learning about tuples in the further chapters) in the format (quotient, remainder).

```
divmod(9,2)
```

```
(4, 1)
```

## Accepting User Inputs

`input(prompt)`

, prompts for and returns input as a string. A useful function to use in conjunction with this is `eval()`

which takes a string and evaluates it as a python expression.

*Note:* In notebooks it is often easier just to modify the code than to prompt for input.

```
abc = input("abc = ")
abcValue=eval(abc)
print(abc,'=',abcValue)
```

```
abc = 2 + 3*4
2 + 3*4 = 14
```

```
```