Basic introduction of python

Basic introduction of python#

Setting the environment for Python#

Anaconda : Include essential packages for basic scientific computation. It is easy to install it just follow the instruction.
Not required, but easy to use for beginners.

Why numerical approach?#

Need to confirm the mechanism of your idea#

An idea for the novel physics
Numerical experiments driven by scientific ideas
Numerical experiments driven theoretical ideas

Need to connect with real experiments#

To strenthen the abstract idea and connect with real world
Get additional information that is difficult to access in experiments and make prediction that is accessible for experiments

Numerics for many body physics is non-trivial!#

The problem itself is a intelletral challenging and interesting discrete mathmetical problems.
Hardware limitation force one to think in a smart way

Generate data to convey what you mean#

Statistics
Plots

My point of view of numerical approaches#

Level of numerical loading#

Light: Mathematica, Python, matlab (For quick checking and benchmark. Once the simple concept passes, use the medium or heavy numerical approach)
Heavy: C/C++, Fortran

Why Python?#

Simple, well-structured, general-purpose language#

Readability great for quality control and collaboration
Code how you think: many books now use python as pseudocode

High-level#

Rapid development
Do complicated things in few lines

Interactive#

Rapid development and exploration
No need to compile, run, debug, revise, compile
Data collection, generation, analysis and publication plotting in one place

Speed#

Usually plenty fast – will discuss more
Your development time is more important than CPU time
Not as fast as C, C++, Fortran but these can be easily woven in where necessary

Vibrant community#

Great online documentation / help available
Open source

Rich scientific computing libraries#

Don’t reinvent the wheel. Only reinvent important wheels!

Accessible for everyone. No need to pay money#

Scientific Python Key Components#

The core pieces of the scientific Python platform are:

Python, the language interpreter

Many standard data types, libraries, etc
Python 3.7 is the current version; use this
Python 2.7 (released 2010) is still maintained but will die in 2020

Jupyter: notebook based (in browser) interface

Builds on IPython, the interactive Python shell
Interactive manipulation of plots
Easy to use basic parallelization
Lots of useful extra bells and whistles for Python

Numpy, powerful numerical array objects, and routines to manipulate them.

Work horse for scientific computing
Basic linear algebra (np.linalg)
Random numbers (np.random)

Scipy, high-level data processing routines.

Signal processing (scipy.signal)
Optimization (scipy.optimize)
Special functions (scipy.special)
Sparse matrices and linear algebra

Matplotlib, plotting and visualization

2-D and basic 3-D interactive visualization
“Publication-ready” plots
LaTeX labels/annotations automagically

Pandas, data analysis/management

data structures for relational data manipulation
useful in observational/numerical analysis
Won’t discuss here

Mayavi, 3-D visualization

For more sophisticated 3-D needs (won’t discuss)

Jupyter Workflow#

Two primary workflows:#

Work in a Jupyter/IPython notebook. Write code in cells, analyze, plot, etc. Everything stored in .ipynb file.
Write code in .py files using a text editor and run those within the IPython notebook or from the shell.

We still stick to the first.

While you are using a notebook, there is a kernel running which actually executes your commands and stores your variables, etc. If you quit/restart the kernel, all variables will be forgotten and you will need to re-execute the commands that set them up. This can be useful if you want to reset things. The input and output that is visible in the notebook is saved in the notebook file.

Note: .py files are called scripts if they consist primarily of a sequence of commands to be run and modules if they consist primarily of function definitions for import into other scripts/notebooks.

Notebook Usage#

Two modes: editing and command mode.

Press escape to go to command mode. Press return to go into editing mode on selected cell.

In command mode:

Press h for a list of keyboard commands.
Press a or b to create a new cell above or below the current.
Press m or y to convert the current cell to markdown or code.
Press shift-enter to execute.
Press d d to delete the current cell. (Careful!)

In editing mode:

Press tab for autocomplete
Press shift-tab for help on current object
Shift-enter to execute current cell

Two types of cells:

Markdown for notes (like this)
Code for things to execute

Exercise

Try editing this markdown block to make it more interesting. For example, type in some equations \(e^{i\pi}+1=0\).

Exercise

Execute the next block and then create a new block, type x. and press tab and shift-tab.

x = 10

Exercise

Run this stuff.

print('Hello, world!')

Hello, world!

"Hello, world!"

'Hello, world!'

2.5 * 3

7.5

3**3

3 + 3

"ab" + "cd"

'abcd'

"Hello" == 'Hello'

True

Variables and Objects#

Everything in memory in Python is an object. Every object has a type such as int (for integer), str (for strings) or ndarray (for numpy arrays). Variables can reference objects of any type and that type can change.

The equals sign in programming does not mean ‘is equal to’ as in math. It means ‘assign the object on the right to the variable on the left’.

a = 3

type(a)

int

a+a

2+a

import numpy as np

---------------------------------------------------------------------------
ModuleNotFoundError                       Traceback (most recent call last)
Cell In[14], line 1
----> 1 import numpy as np

ModuleNotFoundError: No module named 'numpy'

a = np.array([1,2])

array([1, 2])

type(a)

numpy.ndarray

# All objects have properties, accessible with a .
a.shape

(2,)

a+a

array([2, 4])

2+a

array([3, 4])

a = "Hello, world!"

'Hello, world!'

type(a)

str

a+a

'Hello, world!Hello, world!'

2+a

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/tmp/ipykernel_128278/1750888518.py in <module>
----> 1 2+a

TypeError: unsupported operand type(s) for +: 'int' and 'str'

Overloading#

Operators and functions will try to execute no matter what type of objects are passed to them, but they may do different things depending on the type. + adds numbers and concatenates strings.

Variables as References#

All variables are references to the objects they contain. Assignment does not make copies of objects.

a = np.array([1,2])
a

array([1, 2])

b = a
b

array([1, 2])

b[0] = 0
b

array([0, 2])

array([0, 2])

Types of Objects#

Basic Types#

Numeric, Immutable
Integer: -1, 0, 1, 2, …
Float: 1.2, 1e8
Complex: 1j, 1. + 2.j
Boolean: True, False
Strings, “hi”
Tuples, (2,7, “hi”)

Ordered collection of other objects, represented by parentheses
can’t change after creation (immutable)

Lists, [0,1,2,”hi”, 4]

Ordered collection of other objects, represented by square brackets
can add/remove/change elements after creation (mutable)

Dictionaries, {‘hi’: 3, 4: 7, ‘key’: ‘value’}
Functions, def func()

Common Scientific Types#

NumPy arrays, array([1,2,3])

Like lists but all entries have same type

Sparse arrays, scipy.sparse
Pandas DataFrames, high level ‘table’ a bit like an excel spreadsheet

Basic Types: Numeric#

There are 4 numeric types:

int: positive or negative integer
float: a ‘floating point’ number is a real number like 3.1415 with a finite precision
complex: has real and imaginary part, each of which is a float
bool: two ‘Boolean’ values, True or False

a = 4
type(a)

int

c = 4.
type(c)

float

a = 1.5 + 0.1j
type(a)

complex

a.real

1.5

a.imag

0.1

flag = (3>4)
flag

False

type(flag)

bool

type(True)

bool

# Type conversion
float(1)

1.0

Careful with integer division!#

In Python 3, dividing integers promotes to a float. Use // for integer division.

3/2

1.5

3/2.

1.5

Force integer division:

3//2

Basic Types: Strings#

Strings are immutable sequences of characters. This means you can’t change a character in the middle of a string, you have to create a new string.

Literal strings can be written with single or double-quotes. Multi-line strings with triple quotes. ‘Raw’ strings are useful for embedding LaTeX because they treat backslashes differently.

'Hello' == "Hello"

True

a = """This is a multiline string.
Nifty, huh?"""

'This is a multiline string.\nNifty, huh?'

print("\nu")

print(r"\nu")

\nu

a = 3.1415

# Simple formatting (type convert to string)
"Blah " + str(a)

'Blah 3.1415'

# Old style string formatting (ala sprintf in C)
"Blah %1.2f, %s" % (a, "hi")

'Blah 3.14, hi'

# New style string formatting 
"Blah {:1.2f}, {}".format(a, "hi")

'Blah 3.14, hi'

Basic Types: Lists#

Python lists store ordered collections of arbitrary objects. They are efficient maps from index to values. Lists are represented by square brackets [ ].

Lists are mutable: their contents can be changed after they are created.

It takes time O(1) to:

Lookup an entry at given index.
Change an item at a given index.
Append or remove (pop) from the end of the list.

It takes time O(N) to:

Find items by value if you don’t know where they are.
Remove items from near the beginning of the list.

You can also grab arbitrary slices from a list efficiently.

Lists are 0-indexed. This means that the first item in the list is at position 0 and the last item is at position N-1 where N is the length of the list.

days_of_the_week = ["Sunday","Monday","Tuesday",
                    "Wednesday","Thursday","Friday"]

days_of_the_week[0]

'Sunday'

# The slice from 2 to 5 (inclusive bottom, exclusive top)
days_of_the_week[2:5]

['Tuesday', 'Wednesday', 'Thursday']

days_of_the_week[-1]

'Friday'

# every other day
days_of_the_week[0:-1:2]

['Sunday', 'Tuesday', 'Thursday']

# every other day (shorter)
days_of_the_week[::2]

['Sunday', 'Tuesday', 'Thursday']

# Oops!
days_of_the_week.append("Saturday")

days_of_the_week[-1]

'Saturday'

days_of_the_week[5] = "Casual Friday"

days_of_the_week

['Sunday',
 'Monday',
 'Tuesday',
 'Wednesday',
 'Thursday',
 'Casual Friday',
 'Saturday']

# Get the length of the list
len(days_of_the_week)

# Sort the list in place
days_of_the_week.sort()

days_of_the_week

['Casual Friday',
 'Monday',
 'Saturday',
 'Sunday',
 'Thursday',
 'Tuesday',
 'Wednesday']

Remember tab completion Every thing in Python (even the number 10) is an object. Objects can have methods which can be accessed by the notation a.method(). Typing a. allows you to see what methods an object a supports. Try it now with days_of_the_week:

days_of_the_week.

  File "<ipython-input-64-56fb3f712b66>", line 1
    days_of_the_week.
                     ^
SyntaxError: invalid syntax

Each item is arbitrary: You can have lists of lists or lists of different types of objects.

aList = ["zero", 1, "two", 3., 4.+0j]
aList

['zero', 1, 'two', 3.0, (4+0j)]

listOfLists = [[1,2], [3,4], [5,6,7], 'Hi']

listOfLists[2][1]

Basic Types: Dictionaries#

A dictionary is an efficient map from keys to values. They are represented by curly brackets {}.

Dictionaries are mutable but all keys must be immutable. IE. keys can be strings, numbers, or tuples thereof but not lists or other dictionaries. Values can be anything.

It is unordered but takes time O(1) to:

Lookup a value from a key
Add a key, value pair
Remove a key, value pair

It takes time O(N) to find an entry with a particular value.

You can iterate through all the entries efficiently O(N).

tel = {'emmanuelle': 5752, 'sebastian': 5578}
tel['francis'] = 5915

tel

{'emmanuelle': 5752, 'sebastian': 5578, 'francis': 5915}

tel['sebastian']

tel.keys()

dict_keys(['emmanuelle', 'sebastian', 'francis'])

tel.values()

dict_values([5752, 5578, 5915])

len(tel)

'francis' in tel

True

del tel['francis']

tel

{'emmanuelle': 5752, 'sebastian': 5578}

Basic Types: Tuples#

A tuple is an ordered collection of objects. They are represented by round parantheses ().

Tuples are almost like lists but they are immutable. This means that they cannot be changed once they are created.

t = (1,2,3,'Hi')
t

(1, 2, 3, 'Hi')

# IMMUTABLE !
t[0] = 2

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-78-e89466f5bd6a> in <module>
      1 # IMMUTABLE !
----> 2 t[0] = 2

TypeError: 'tuple' object does not support item assignment

The empty tuple and length 1 tuples have special notation since parentheses can also represent grouping.

emptyTuple = ()
emptyTuple

()

lengthOne = ('hi',)
lengthOne

('hi',)

notLengthOne = ('hi')
notLengthOne

'hi'

notLengthOne[0]

'h'

Control Flow#

The flow of a program is the order in which the computer executes the statements in the code. Typically, this is in order from top to bottom. However, there are many cases where we want to change the flow in some way. For example, we might want to divide two numbers but only if the divisor is not zero. Or we might want to iterate: repeat a block of code many times for each value in some list. The commands which allow these are called control flow commands.

WARNING: Python cares about white space! You must INDENT CORRECTLY because that’s how Python knows when a block of code ends.

Typically, people indent with 4 spaces per block but 2 spaces or tabs are okay. They must be consistent in any block.

If/elif/else#

if 2>3:
    print("Yep")
    print("It is")

elif 3>4:
    print("Not this one either.")
    
else:
    print("Not")
    print("At all")

Not
At all

For Loops#

For loops iterate through elements in a collection. This can be a list, tuple, dictionary, array or any other such collection.

These are the most Pythonic way to think about iterations.

for i in range(5):
    j = i**3
    print("The cube of " + str(i) + " is " + str(j))

The cube of 0 is 0
The cube of 1 is 1
The cube of 2 is 8
The cube of 3 is 27
The cube of 4 is 64

for day in days_of_the_week:
    print("Today is " + day)

Today is Casual Friday
Today is Monday
Today is Saturday
Today is Sunday
Today is Thursday
Today is Tuesday
Today is Wednesday

for key in tel:
    print(key + "'s telephone number is " + str(tel[key]))

emmanuelle's telephone number is 5752
sebastian's telephone number is 5578

Enumerate to get index and value of iteration element

words = ('your', 'face', 'is', 'beautiful')

for (i, word) in enumerate(words):
    print(i, word)

your
face
is
beautiful

While Loops#

Repeats a block of code while a condition holds true.

x = 5

while x > 0:
    print("Bark " + str(x))
    x -= 1

Bark 5
Bark 4
Bark 3
Bark 2
Bark 1

Functions#

Any code that you call multiple times with different values should be wrapped up in a function. For example:

def square(x):
    """Return the square of x."""
    return x*x

square?

square(9)

def printAndSquare(x):
    """Print the square of x and return it."""
    y = x**2
    print(y)
    return y

printAndSquare?

printAndSquare(8)

Functions are Objects#

Functions are just like any object in Python:

type(square)

function

Make another variable refer to the same function:

a = square

a(5)

A function being passed to another function.

def test():
    print("In Test!")
    return

def callIt(fun):
    print("In callIt!")
    fun()
    return

callIt(test)

In callIt!
In Test!

Basic introduction of python

Contents

Basic introduction of python#

Setting the environment for Python#

Why numerical approach?#

Need to confirm the mechanism of your idea#

Need to connect with real experiments#

Numerics for many body physics is non-trivial!#

Generate data to convey what you mean#

My point of view of numerical approaches#

Level of numerical loading#

Why Python?#

Simple, well-structured, general-purpose language#

High-level#

Interactive#

Speed#

Vibrant community#

Rich scientific computing libraries#

Accessible for everyone. No need to pay money#

Scientific Python Key Components#

Jupyter Workflow#

Two primary workflows:#

Notebook Usage#

Variables and Objects#

Overloading#

Variables as References#

Types of Objects#

Basic Types#

Common Scientific Types#

Basic Types: Numeric#

Careful with integer division!#

Basic Types: Strings#

Basic Types: Lists#

Basic Types: Dictionaries#

Basic Types: Tuples#

Control Flow#

If/elif/else#

For Loops#

While Loops#

Functions#

Functions are Objects#