Jupyter :: More Python

• This notebook shows some additional features of Python.
• It can help you to understand better the examples from EM lectures.
• Hovever, the Python features below are useful, but not necessary for solving homework...
• On the other hand, this notebook still quite simple $\Rightarrow$ not a replacement of more detailed Python tutorials:
  • help within Jupyter: Menu - Help - Python reference
  • local docs: Python documentation - The Python Tutorial - An informal introduction
  • equivalent of the local docs in www: https://docs.python.org/3/tutorial/
  • tutorial focused on Python for science: https://problemsolvingwithpython.com/
  • detailed, perphaps the best free tutorial about Python for science: https://scipy-lectures.org/

1. Data types

• Incomplete list of data types in Python:
  • basic: int (integer numbers), float (real numbers), str (strings = words)
  • collections: list (sequence of elements), tuple (constant list), dictionary (sequence of key/value pairs)

1.1. Basic data types

# Create int, float and string
year = 2019
pi   = 3.14
name = 'Mirek'

# Print the created variables
print(year,pi,name)

2019 3.14 Mirek

# Print the types of created variables
type(year),type(pi),type(name)

(int, float, str)

1. 2. Collections

1.2.1 Collections: list and tuple

• List = ordered sequence of elements
• Tuple = constant list = list with elements that cannot be changed

# Create two lists (with square brackets)
a = [1,2,3]
b = ['red','blue']

# Create one tuple (with round brackets)
c = ('The answer is', 42)

# Print the whole lists and tuples
print(a)
print(b)
print(c)

[1, 2, 3]
['red', 'blue']
('The answer is', 42)

# Access individual elements (always with square brackets)
print(a[0], a[0]+10, a[0]+a[1])
print(c[0],c[1])

1 11 3
The answer is 42

# Print the types of our variables
type(a), type(b), type(c)

(list, list, tuple)

1.2.2 Collections: dictionary

• Dictionary = sequence of key/value pairs
• The elements of dictionary are accessed by keys, not by indexes

# Create a dictionary (with curly brackets)
d = {'H':1,'He':2,'Li':3}

# Print the whole dictionary
print(d)

{'H': 1, 'He': 2, 'Li': 3}

# Access individual elements (always with square brackets)
d['Be'] = 4
d['B'] = d['Be'] + 1
print(d)

{'H': 1, 'He': 2, 'Li': 3, 'Be': 4, 'B': 5}

# Print the type of our variable
type(d)

dict

2. Control flow tools

• Control flow = control of the flow of the program
• Here - just three basic structures:
  • if conditions = decision based on conditions
  • for cycles = repeating of statements/actions
  • while cycles = repeating based on condition

2.1. If-conditions

# This value can be changed by user...
a = 10

# Condition (elif and/or else statemens can be omitted)
if (a > 0):
    print('Number is positive')
elif (a == 0):
    print('Number is zero')
else:
    print('Number is negative')

Number is positive

2.2. For-cycles

# Basic syntax...
for b in (1,2,3):
    print(b, end=' ')

1 2 3 

# Slightly more complex example - temperature conversion table
# Convert degrees of Celsius to degrees of Kelvins, Fahrnheit and Reaumur

# (1) Print simple header of the table
print('%5s %7s %6s %6s' % ('T[C]','T[K]','T[F]','T[R]'))
print('-'*28)
# (2) Calculate and print conversion table
for x in range(0,21,2):
    deg_C = x
    deg_K = x + 273.15
    deg_F = x * 9/5 + 32
    deg_R = x * 0.8
    print('%5.1f %7.2f %6.1f %6.1f' % (deg_C, deg_K, deg_F, deg_R))

 T[C]    T[K]   T[F]   T[R]
----------------------------
  0.0  273.15   32.0    0.0
  2.0  275.15   35.6    1.6
  4.0  277.15   39.2    3.2
  6.0  279.15   42.8    4.8
  8.0  281.15   46.4    6.4
 10.0  283.15   50.0    8.0
 12.0  285.15   53.6    9.6
 14.0  287.15   57.2   11.2
 16.0  289.15   60.8   12.8
 18.0  291.15   64.4   14.4
 20.0  293.15   68.0   16.0

2.3 While-cycles

# Basic syntax...
c = 0
while c < 10:
    c = c + 1
    print(c, end=' ')

1 2 3 4 5 6 7 8 9 10 

# Slightly more complex example - greatest common divisor = GCD
# Euclid's algorithm

# (1) Insert two natural numbers (integers > 0)
a = 32
b = 40
# (2) Calculate GCD according to Euclid's algorithm
while (a != b):
    if (a>b):
        a = a-b
    else:
        b = b-a
# (3) Print the result
print(a)

8

3. Examples: simple small programs

3.1. Factorial

• Factorial is a function used in mathematics, namely in combinatorics.
• More information: https://en.wikipedia.org/wiki/Factorial
• Definition: n! = 1 * 2 * ... * n
• Example: 3! = 1 * 2 * 3 = 6

# Define factorial
def factorial(n):
    factorial = 1
    for i in range(1,n+1):
        factorial = factorial * i
    return(factorial)

# Calculate factorial for a few numbers
for n in range(6):
    print('n = %-3d  n! = %-6d' % (n, factorial(n)))

n = 0    n! = 1     
n = 1    n! = 1     
n = 2    n! = 2     
n = 3    n! = 6     
n = 4    n! = 24    
n = 5    n! = 120   

3.2. Fibonacci sequence

• Fibonacci sequence (and corresponding Fibonacci numbers) appear unexpectedly often in mathematics and biology.
• More information: https://en.wikipedia.org/wiki/Fibonacci_number
• Definition: F(0)=0, F(1)=1, F(n)=F(n-1)+F(n-2)
• Example: 0,1,1,2,3,5,8...

# Print Fibonacci numbers up to F(n)
# (straightforward, step-by-step algorithm

# n = number of Fibonacci nubmers, can be changed
n = 20

# fn2,fn1 = initial values of F(n-2),F(n-1)
fn2,fn1 = 0,1

# print initial Fibonnaci numbers
print('%d,%d' % (fn2,fn1), end=',')

# calculate and print remaining Fibonacci numbers
for i in range(n-2):
    fn  = fn1 + fn2
    fn2 = fn1
    fn1 = fn
    print(fn, end=',')

# print final elipsis = ...
print('...')

0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,...

# Alternative, slightly shorter and a bit more clever algorithm
# (taken and adjusted from Python tutorial
n = 20
a,b = 0,1
for i in range(n):
    print(a,end=',')
    a,b = b,a+b
print('...')

0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,...

3.3. Quadratic equation

• Quadratic equation is known from elementary school.
• Reminder and more details: https://en.wikipedia.org/wiki/Quadratic_equation

from math import sqrt

# Input coefficients a,b,c
# (this part can be changed by user
a = 1
b = 0
c = -4

# Calculate discriminant
d = b**2 - 4*a*c

# Calculate roots of quadratic equation
print('Equation to solve: a*x**2 + b*x + c = 0')
print('Coefficients (a, b, c): %d, %d, %d ' % (a,b,c))
print('----')
# ...special cases (a,b == 0), which would cause errors...
if (a == 0):
    if (b == 0):
        print('Special case (a=0,b=0) => nonsense, no solution.')
    else:
        x = -c/b
        print('Special case (a=0) => linear equation: x =',x)
# ...other cases, quadratic equation with (a,b != 0)
else:
    if (d > 0):
        x1 = (-b + sqrt(d)) / (2*a)
        x2 = (-b - sqrt(d)) / (2*a)
        print('Quadratic equation, two real solutions:', x1, x2)
    elif (d == 0):
        x = -b / (2*a)
        print('Quadratic equation, one real solution:', x)
    else: # (d < 0)
        print('Quadratic equation, no real solution.')

Equation to solve: a*x**2 + b*x + c = 0
Coefficients (a, b, c): 1, 0, -4 
----
Quadratic equation, two real solutions: 2.0 -2.0

4. Conclusion

• The Python syntax shown above is very simple, basic and introductory.
• Nevertheless, it has been demonstrated that it is sufficient for short programs.
• If you want to learn more, use the recommended references above or search internet.
• There is a plenty of Python tutorials on www, it would be ineffective to write another one.