## 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

- 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)

----> 1 11.0**300

OverflowError: (34, 'Numerical result out of range')


### Relational Operators

== 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