Python Introductory Course: the basis¶
With emphasis on data-science problems
This course is available on gitlab
Contact us: andrea.dotti@gmail.com, mancinit@infn.it
Introduction¶
The who - Andrea¶
- I am a (HEP) physicist as background, I worked at CERN and SLAC/Stanford:
- Geant4 Collaboration member: parallelization, HPC, physics validation
- ATLAS Experiment member: simulations and data-analysis
- Worked briefly at LCLS-II: off-line software design
- I have recently moved to the private sector and I am working as a data scientist
I am very lucky to have had the opportunity to see both sides of data-analysis and large data-analytics. I program in C++ and Python with the latter used (mainly) for data-analysis.
The who - Carlo¶
- I am a physicist, I am working at Sapienza/INFN (Roma1):
- Geant4 Collaboration member: low energy nuclear interaction models
- R&D of detectors for Medical Applications and related MC simulations and data analysis
- Since a few we started applying Deep Learning to medical data
I program in C++ and Python with the latter used for data and medical images analysis and Deep Learning applications.
The Why¶
Python is one of the fastest growing programming language (among the most populars in industry, the second most active on github, and number 4 on stackoverflow ).
It is getting more and more traction for science and basic research problems (see here, here, here), thus it is a good moment to learn it.
I am not an expert of Python, but I hope to be able to give you:
- Some insights on the programming language itself
- A feeling of what python is good for (and what is not good for)
- Examples and applications to the problem of data-science
Python Language¶
Python is an interpreted, high-level, general-purpose programming language. Created by Guido van Rossum and first released in 1991, Python's design philosophy emphasizes code readability with its notable use of significant whitespace. Its language constructs and object-oriented approach aims to help programmers write clear, logical code for small and large-scale projects. Python is dynamically typed and garbage-collected. It supports multiple programming paradigms, including procedural, object-oriented, and functional programming. Python is often described as a "batteries included" language due to its comprehensive standard library.
From Wikipedia)
Interpreted language¶
The python interpreter reads the input (interactive or in a script) and executes each line of code sequentially. A python distribution comes with a REPL (Read Evaluate Print Loop) shell. E.g.:
# Technical notes, for this course, we use conda. In each
# new terminal type:
conda activate pycourse
python
Which will give you:
Python 3.7.3 (default, Mar 27 2019, 22:11:17)
[GCC 7.3.0] :: Anaconda, Inc. on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
the >>> sequence is the python prompt, type a command and see the result, for example:
a = 3+2
print(a)
Hint:Type Ctrl+D to exit, or type quit().
Interpreted language¶
Other (python) shells are available, to simplify/improve the user-experience, for example IPython (ipython), or GUIs (jupyter integration).
We will talk about these in the next slide deck.
High-level¶
Python strongly abstracts the specific hardware details.
- This means that on one side it makes easier to program (e.g. no explicit memory handling, forget about new/delete)
- On the other side the interpreter must work more to translate user input to machine code, this fact together with the interpreted nature of it, makes the code slower compared to a lower-level programming language (e.g. C++).
Python is not a good language for performance critical applications. Use a lower level language instead.
It is a very good prototype language.
Python is not does not support threads (due to the global lock), but has some (heavier) multiprocessing capabilities.
Python is excellent for data analysis and/or data manipulation (ETL).
Is python really slow?¶
Python usually provides a very rich set of libraries and it supports C-binding allowing for offloading computationally heavy parts of the code to optimized routines.
Hint: if you know that you have a computationally expensive routine, check if it is available in some libraries, it is probably well optimized (e.g. do not write your own linear algebra functions, use scipy.linalg).
Hint: some popular libraries or extension even come with GPU support to speed up the calculations if you have access to the hardware (e.g. tensorflow vs tensorflow-gpu).
General Purpose¶
Python can be used for a rich set of applications:
- Web applications
- Data gathering and manipulation
- Scientific computation
- Data science
Traditionally, python is considered a glue language, used to coordinate programs (possibly written in other languages) and to manipulate the input and output from one to the other (a pipeline). Consider it, for this aspect, as a bash on steroids.
However the growing number of specialized libraries (e.g. the scientific python stack), powerful visualization tools and rich I/O capabilities, has made it very popular among data scientist and for scientific computations.
History¶
- Implementation started in 1989
- Python 2.0 released in October 2000
- Python 3.0 released in December 2008
Python 3.0 is not backward compatible: a program written for python 2 may not run in python 3 out of the box (and vice versa). python3 is getting more and more traction and ver. 2 will retire soon:
If you are starting now with python, go directly to version 3, if you are still at 2, start migration!
- Some more conservative linux distributions tend to have older python interpreter installed (e.g. CentOS-7 includes python 2.7)
- We'll see how to avoid this problem and use a more recent python interpreter (hint: conda to the rescue)
Please note:¶
what is 1 divided by 2?
- python 2.x:
#1/2
1//2 #because I'm using python 3
- python 3.x:
from __future__ import division #if using python2
1/2
The future module¶
You can import python 3 keywords and features in python 2 from the __future__!
do that if you are using python 2.x, your code will support python 3.x
Main differences between 2 and 3¶
- Division
- Print function
rangeandxrange
Print function¶
print 'Hello, World!'
print('Hello, World!')
- printing variables
from platform import python_version
print('Python', python_version())
- how to print twice on the same line?
print("some text,", end="")
print(' print more text on the same line')
Integer division¶
The most dangerous difference
the change in integer-division behavior can often go unnoticed
it doesn’t raise a SyntaxError
I recommend a from __future__ import division in python 2
and write explicitly 1./2
range and xrange¶
The usage of xrange() is very popular in python 2.x for creating an iterable object, e.g., in a for-loop or list/set-dictionary-comprehension.
In python 3, the range() was implemented like the xrange() function
range(0,5)
x = range(0,5)
type(x)
a dedicated xrange() function does not exist anymore
xrange(0,5)
range is lazy¶
Only when you consume it, will it actually be evaluated - in other words, it will only return the numbers in the range when you actually need them.
for i in range(0, 5):
print(i,"\t",end="")
like a generator:
# this is a list, create all values in memory, by using []
lis = [x/2 for x in range(5)]
lis
# this is a generator, creates each x/2 value only when it is needed, uses ()
gen = (x/2 for x in range(5))
gen
How to force range to a list¶
some functions and methods (like range) return iterable objects in python 3 instead of lists in python 2
Since we usually iterate over those only once anyway, we save memory.
However, it is also possible - in contrast to generators - to iterate over those multiple times if needed, it is only not so efficient.
If a list-objects is really needed, we can simply convert the iterable object:
list(range(5))
next¶
gen = (x/2 for x in range(5))
for i, val in enumerate(gen):
print("i:",i,"value:",val)
gen = (x/2 for x in range(5))
next(gen)
next(gen)
gen.next() # python 2
Rounding¶
in python 3, decimals are rounded to the nearest even number
round(15.5)
round(16.5)
it’s supposedly a better way of rounding compared to rounding up as it avoids the bias towards large numbers
For more information:
https://en.wikipedia.org/wiki/Rounding#Round_half_to_even
https://en.wikipedia.org/wiki/IEEE_floating_point#Roundings_to_nearest
Getting Python¶
- The version number specifies the capabilities of the system (i.e. what the interpreter can understand) and the content of the python standard library (that comes with the interpreter)
- A distribution is a packaging of an interpreter and a selection of libraries. For example the official CPython one, the PyPy -optimized for performances- one, and specialized ones, like Anaconda, are all distributions
Python code organization¶
Code is written in modules: a file containing functions, global variables, classes. Differently from C++ and Geant4, usually one module contains more than one class/function all related to each other (it would be like if in Geant4 all classes related to EM Bremsstrahlung are in a single file). Note: in python there is no .hh/.cc distinction (no forward declaration), in C++ terminology: everything is inlined.
#Import a single module and use a function in it
import os
print(os.uname())
# IT is possible to import a single function from a module. And (optionally change its name)
from os import uname as un
print(un())
A package is a directory containing one or more modules (or sub-packages). The directory must contain a special file __init__.py that tells python that the directory is a package. The content of the file can tailor the package behavior (see here for details).
#Import a package
import numpy
#Import a module from a package
import numpy.random as rnd
print("Call 1:",rnd.binomial(10,0.5))
#Import a function
from numpy.random import binomial
print("Call 2:",binomial(10,0.5))
#Depending on how the __init__ file is written it is possible to:
from numpy.random import *
print("Call 3:",binomial(10,0.5))
#I do not recomment import * since you may have name clashes...
Since we are here...¶
Python has a built-in function help(...) that can be very useful:
help(binomial)
Documentation is written together with the code as comments. If you follow some specific rules (see here) you get pretty nicely formatted documentation (tools exist to create documentation from code):
def foo():
'''
This is the documentation.
It is written as multi-line comment
'''
# This is a single line comment
return
help(foo)
Let's get started¶
Firing-up the python interpreter¶
- Type
pythonto enter the interactive python interpreter.quit()(orCtrl+d) to quit
- If you want to execute a script (a file containing some python code) type at the shell prompt:
python myscript.py
- You can execute python commands without entering the python interpreter:
python -c "print(3+2)" - Modules may also be executed as scripts, in such a case:
python -m os
- But you can enter interactive mode after importing a module, or executing commands:The
pyton -i -m os
-ishould come before-m. Whatever follows the name of the module is passed as arguments to it!
A note on encoding and scripts¶
Scripts, by default, are encoded in UTF-8 (terminal and font must support special character if you use them). You can specify a different encoding adding this special comment line as the first line in your .py file:
# -*- coding: cp1252 -*-If you use UNIX shebangs this line can be put as second, as in:
#!/usr/bin/env python
# -*- coding: cp1252 -*-The first python session: variables, types and data structures¶
Let's start the python interpreter and define some variables:
#This is a comment
a = 3 #This is an integer, this is a comment on the same line
b = 2.3 #This is a float (actually a double 64-bits in C++)
print('a is of type {}, b is of type {}'.format(type(a), type(b)))
print('a value is {}, while b\'s is {}'.format(a, b))
=is the assignment operator: assigns the rhs to the variable on the lhs (e.g.n = 3)- Arithmetic operations are the usual ones:
+,-,*,/ - Important: Division
/returns afloat(e.g.5 / 2returns 2.5) in python3 but not always in python2 (e.g.5 / 2returns 2, while5./2.returns 2.5). Remember this is you are porting code from 2 to 3! - In python3
//is theflooroperation (e.g.5 // 2returns 2). %is the reminder operator**is the exponent operator
Talking of variables...¶
Python is an inferred, dynamically and strongly typed language. This means:
- Variable types are guessed by the interpreter (like using everywhere
autoin C++11)
- The same variable name can be re-used for another type
- IMPORTANT: the variable name is just a name, pointing to an underlying object, that has a specific type
a = 1 #a is an int
print(type(a))
a = "abc" #Now a points to a string
print(type(a))
Memory is automatically managed, and you can think of everything like an instance of a class:
a = 3
#Print memory address id(..) in hexadecimal format hex(...)
print(hex(id(a)))
a = 3.2
print(hex(id(a)))
Note the two addresses are different, even if the variable name is the same, python interpreter takes care of cleaning the memory, when not needed anymore.
Side Note: In an interactive session, you do not need to write print to show the return value of the last statement. E.g. writing a directly at the interpreter is equivalent to print(a).
String type¶
Strings are enclosed in '...' or "...". Multi-line literals are allowed using """..."""/'''...''' as in the following example:
str1 = "A string"
str2 = 'Another string'
print(str1)
print(str2)
print("""First line
Second line
Third line
""")
String manipulation is supported with + (concatenation) and * (repetition), as in:
a = 'First string, '
b = 'Second string'
print(a+b)
print(3*"abc")
Special character can be escaped with \ (e.g. \n to produce a new line). Unless the string is a raw string, in such a case the \ are interpreted as character:
str1 = 'Special \t character'
str2 = r'A raw string with special \n character' #Note the r'...'
print(str1)
print(str2)
Strings can be indexed and sliced:
message = "A message"
#First and third characters
print( message[0] )
print( message[2] )
#Last and second to last characters
print( message[-1] )
print( message[-2] )
#Substring from 4rd to 5th characters (0-indexed up to 6 excluded)
print( message[3:6] )
#Substring from beginning to 2nd character
print( message[:3] )
#Substring from 6th to the end
print( message[5:] )
Side note: f-strings¶
Python3 has a special f(ormatted)-string construct:
variable = 3
fstring = f'An f-string: {variable}, look at me!'
print(fstring)
In a f-string, the {...} characters are replaced with the value of the variable name.
Lists, tuples and dictionaries¶
There is a number of containers data structures:
- list are read/write containers of objects that can be indexed, sliced and much more
alist = [ 1, 2, 3, 4]
list3 = [1, 3.3, "aaa", 3+3j ]
- tuples are read-only compounds objects, useful to write compact code (packing/unpacking)
atuple = (1, 2, 3, "aaa") #() are actually not needed
(first, second, third, fourth) = atuple #also here () are not needed
- dictionaries are collections of key/value pairs
dict1 = { 'value1' : 3.2 , 'value2' : "msg", 'value3' : [1,2,3] }
dict2 = dict(value1=3.2, value2="msg", value3=[1,2,3])
dict3 = { #python can accept constructs on multiple lines
'value1' : 3.2,
'value2' : "msg",
'value3' : [1,2,3]
}
More on lists¶
Lists are probably the most useful data structure in python, let's see few more details, starting from some common methods:
a = [ 1,2,3 ]
a.append(4)
a
b = [5,6,7]
a.extend(b)
a
last = a.pop()
print(last)
a
del a[3]
a
a.remove(5)
a
A list comprehension consists of brackets containing an expression followed by a for clause, then zero or more for or if clauses:
[ x**2 for x in range(10) ]
[ x**2 for x in range(10) if x%2 == 0 ]
I use often the following two:
list(enumerate(["a","b","c"]))
list(zip(["a","b","c"],[10,20,30]))
Lists can be transversed with:
alist = [1, 3, 5, 7]
for e in alist:
#do something
pass
alist = [0,1,2,3,4,5,6,7,8,9,10]
alist[2]
alist[-1]
alist[2:4]
alist[2:8:2]
More on dictionaries¶
d = { "a":3, "b":5 }
assert(d["a"]==3)
d.update({"c":6,"a":2})
d
#This has changed between python2 and python3
for k,v in d.items():
print(k,"is",v)
d = { x: x**2 for x in range(5)}
d
d = dict(a=1, b=2, c=3)
d
Finally a useful data structure is set, a collection of unique values. I use this data structure only exclusively to get the list of the unique elements in a list:
a = list(range(5))
a.extend(range(5))
a
s = set(a)
s
Control flow¶
if statement¶
x = 2.3
if x > 10:
print("x is large")
elif x > 5:
print("x is not so large")
else:
print("x is small")
Since we are here¶
Note the indentation: In C++ you use curly brackets {} to delimit code blocks. In python you use indentation (one of the basic principles of python is code readability). Python interpreters and IDEs will help you with code indentation, but if you do not respect it, you will get errors or, worse, wrong behavior.
A command line tool like pylint can help you check a module/script respects code standards. It is worth trying it out if you need to share the code with someone else.
for statement¶
alist = ["one", "two", "three"]
message = ""
for element in alist:
message = message + "," + element
#Python is coincise, the same can be achieved using the method
#join of str object:
message = ",".join(alist)
message
break and continue have the same behavior as in C/C++, in addition for supports the else clause, as in the example:
prime_numbers = list()
for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
# n is not a prime number, we have found a factor
break
else:
#Note here else is alligned with for, not the if!
# loop fell through without finding a factor
prime_numbers.append(n)
#Python is also functional (this is not a good idea, do you know why?):
prime_numbers = filter(
lambda n: 0 not in map(lambda x: n%x , range(2,n)),
range(2,10)
)
pass statement¶
This statement does nothing: it is useful when the syntax requires something, but there is nothing to do, usually used to create an empty class or a stub for a method to be implemented in the future:
class MyClass:
#TODO: Stop procrastinating and get to work!
pass
Input/Output¶
Writing formatted strings¶
We have already seen f-strings, r-strings and normal strings:
str1 = "A string"
str2 = r"A raw string, with special characters like \n"
somespecialval = 3
#Error if somespecialval is not already defined
str3 = f"An f-string {somespecialval}"
This is the old "C-printf" style, still valid to format a string:
str4 = "Some string with a value inside %d"%3.2
str4
Strings can be formated via the .format method (preferred):
"A string with a first {} and a second {} value".format(3,4)
str1 = "Look here: {0}, {1}".format(1,2)
str2 = "Look here: {1}, {0}".format(1,2)
print(str1)
print(str2)
from math import pi
"A formatted string {0:.3f}".format(pi)
An interesting use case for .format is if you need to print some values from a dictionary:
d = dict(first=1., second="a", third=3)
"A use case where I print only part of the info {first} and {second}".format(**d)
Reading files¶
Let's focus here on reading text files. If you need to do data manipulation there are other formats you may consider that usually come with a dedicated I/O module (e.g. Excel, to matlab, to HDF5).
inf = open("afile.txt","r")
inf.readline()
inf.readline()
inf.readline()
inf.close()
It is good practice to use the following construct to operate on files (because it is safer in case of errors), after the with block, the file is closed automatically:
with open("afile.txt","r") as f:
for line in f:
print(line)
Often in physics we want to read a file containing columns of numerical values (note that we will see more efficient ways to do this):
v1s = list()
v2s = list()
with open("afile.csv","r") as f:
for line in f:
v1, v2 = line.split(",")
v1s.append(float(v1))
v2s.append(float(v2))
print(v1s)
print(v2s)
Writing data to files¶
A file object, opened with 'w' option has the method .write:
with open("outfile.txt","w") as f:
f.write("Some text\n")
A python module called pickle can be used to store/read python data structures:
import pickle
d = dict(key1="ABC", key2=3.2, key3=[1,2,3,4])
with open("outfile.pkl","wb") as f: #b is for binary, more efficient
pickle.dump(d,f)
# Read data back:
with open("outfile.pkl","rb") as f:
d_read = pickle.load(f)
d_read
Finally JSON is an internet standard for data exchange. It is probably worth to note that it is well supported:
d = dict( key1="ABC", key2=3.2, key3=[1,2,3,4])
import json
json.dumps(d) #the 's' here means "dump to string"
with open("outfile.json","w") as f:
json.dump(d,f)
with open("outfile.json","r") as f:
d_read_j = json.load(f)
assert(isinstance(d_read_j, dict))
d_read_j
Defining functions¶
A function is defined with the following syntax def fun_name(arguments):, the return value is implicitly determined by the return statement.
WARNING different code paths (e.g. if-else statements) could make a function return different data types
def foo( arg1, arg2 ):
"""A simple function"""
return arg1+arg2
#Note the return type is dynamic:
assert( isinstance(foo(3,2), int) )
assert( isinstance(foo("a","b"), str) )
Functions can have default arguments, that can be omitted when calling the function:
#Note the special value of arg2, of type NoneType
def foo( arg1, arg2=None ):
"""A simple function"""
if arg2:
return arg1+arg2
else:
return arg1
Functions can be called with positional and keyword arguments:
def foo( arg1, arg2='Value', arg3=None):
pass
foo(100) # 1 positional argument, using 2 defaults
foo(100, "two", 3) # 3 positional arguments
foo(arg2="two", arg1=20) #2 keyword argumnets, note now the order does not matter
A special signature of functions contains (one or both) parameters with a name preceded by * or **. Better explained with an example:
def foo(arg1, *args, **kwargs):
pass
foo(3, "two", "three", key1 = "value1", key2 = "value2")
# Foo's parameter args is the list ["two","three"] and kwargs is a dict { "key1":"value1", "key2":"value"}
This is very useful to write functions that accepts an arbitrary number of arguments. E.g:
def do_something_complex(data, **conf):
"""conf is a 'configuration' dictionary"""
if 'method' in conf and conf['method'] == 'linear':
pass
Lambda expressions¶
In python functions are first class citizens, they are objects that can be passed as argument to other functions:
def foo(a, b):
return a+b
def bar(fun, c):
return fun(c,c)
bar(foo,2)
Lambda expressions can be used to create anonymous functions, usually when these are pretty small:
def bar(fun, c):
return fun(c,c)
#Let's make a variant:
fun2 = lambda a,b: a+b+2
print(type(fun2))
bar(fun2, 3)
Lambdas are useful in combination with many built-in functions like map, reduce and filter. For example map accepts as arguments a function and an iterable. It applies the function to all elements, returning a new iterable. For example:
power_of_two = lambda x: 2**x
inp = range(10) # An iterable of all numbers 0..9
out = map( power_of_two, inp)
out
Note that out is not a list, but an instance of an object (an iterable), let's get the list of the values:
list(out)
The extensive use of iterables in python3 is probably its most confusing feature, especially if you have experience with python2.
On iterables¶
In python3 many function now returns an iterable instead of the collection. An iterable is more efficient than the collection itself, but once consumed, it becomes empty:
out = map(power_of_two, inp)
for e in out:
print(e, end=",")
print("\n once more:")
for e in out:
print(e, end=",") #Never comes here becouse out has been consumed
#If you need to use more than once an iterable you can
# 1. convert it to the underlying data type:
out = map(power_of_two, inp)
out = list(out)
assert( len(out) == len(inp) )
# 2. Or "clone" the iterable itself:
from itertools import tee
out = map(power_of_two, inp)
it1, it2 = tee(out)
Annotating functions¶
In python3 it is possible to document functions specifying the expected type of arguments and return type. Also local variables can be annotated. However the interpreter will allow a call with wrong types, this is purely for documentation/readability:
def some_complex_function( arg1: int, arg2: str) -> bool:
"""An annotated function
The first argument should be an integer, and the second a string.
The function returns a boolean.
Annotations are used to actually avoid writing this documentation..."""
result: bool = str(arg1)==arg2
return result
assert(some_complex_function(3, "3"))
assert(some_complex_function("a", "a")) #Does not fail because str("3") == "3", but type(arg1)!=int
Classes can be annotated too.
Classes¶
Python supports object oriented programming style. However there are few differences with respect to C++:
- All data members are public
- All methods are virtual
class MyClass:
"""Class documentation"""
i = 3 #This is a class data member.
def foo(self): #Note the 'self' keyword
"""This is a class method"""
print("Called method foo!")
m = MyClass()
m.foo()
m.i
Class instances can be dynamically extended:
m.another_val = 3
m.another_val
Constructors exist (the __init__ method), and they are used to initialize instance data-field. There is (usually) no need for a destructor because memory is not managed explicitly (see here for more).
class MyClass:
"""Class documentation"""
i = 3
def __init__(self, val):
"""Consturctor with one parameter"""
self.value = [val] #An instance data member
m = MyClass(3.14)
m.value
Inheritance exists, with the expected behavior:
class Derived(MyClass):
"""A derived class"""
def __init__(self):
MyClass.__init__(self,3.14)#Excplictly call the base class constructor
m = Derived()
m.value
Think twice before writing your own class: if you want just a container for your (heterogeneous) data, a dict is what you are looking for (maybe with few helper functions). At least this is 90% of the use-cases for a HEP user. E.g. instead of:
class Electron:
m = 511
q = -1
name = "electron"
family = "lepton"
def __init__(self,energy):
self.energy = energy
Use:
e1 = dict(m=511,q=-1,name="electron",family="lepton",energy=3)
e2 = e1.copy()
e2.update( dict(energy=2.2))
Private methods/data fields do not exists. However a convention exists, if the field name starts with an _ character, this is considered implementation details:
class MyClass:
"""A class"""
i = 3
_cache = None #Something internal, e.g. a cache
def __init__(self, val):
"""Constructor with one parameter"""
self.value = val
def _update(self):
#some heavy calculation and store an intermediate number
_cache = 3.14
def do_stuff(self):
if self._cache is None:
self._update()
#Rest
class MyClass:
"""Another example"""
__slots__ = [ "value" ]
def __init__(self,val):
self.value = val
self.another = 3
MyClass(3.4)
Finally in python3 there is a useful Enum class to provide enumeration functionalities:
from enum import Enum
class ParticleName(Enum):
#By convention use all capital letters
ELECTRON = "electron"
PROTON = "proton"
class ProcessType(Enum):
EM = 2
HAD = 4
ParticleName.ELECTRON
Decorators¶
Python has strong scoping/namespacing, you can write a function inside another function:
def my_func(a):
a = a**2
def _times_two(a):
return 2*a
return _times_two(a)
my_func(3)
And since functions are first class citizens you can do:
def inform_me(func):
def _wrapper(*args, **kwargs):
print(f"Calling: {func.__name__}!")
return func(*args,**kwargs)
return _wrapper
def my_func(a):
return a**2
my_func = inform_me(my_func)
my_func(2)
@inform_me
def my_func_3(a):
return a**3
my_func_3(2)
If you need to write your own decorator, actually it is best to do it like this:
import functools
def my_decorator(func):
@functools.wraps(func) #Presereves identity of func
def _wrapper(*args, **kwargs):
#do stuff
return func(*args, **kwargs)
return _wrapper
@my_decorator
def a_new_function(a):
return a**4
a_new_function.__name__ #works only thatnks to @functools.wraps
Decorators are pretty powerful, but a bit obscure, not used so much...
But the following is very useful:
class Particle:
__slots__ = [ "mass", "ekin" ]
def __init__(self, m, t):
self.mass = m
self.ekin = t
def energy(self):
return self.mass+self.ekin
p = Particle(1, 2)
p.energy()
class Particle:
__slots__ = [ "mass", "_ekin", "_energy" ]
def __init__(self, m, t):
self.mass = m
self._ekin = t
self._energy = m+t
@property
def energy(self):
return self._energy
@energy.setter
def energy(self, e):
self._energy = e
self._ekin = e - self.mass
@property
def ekin(self):
return self._ekin
@ekin.setter
def ekin(self, val):
self._ekin = val
self._energy = self.mass + self._ekin
p = Particle(m=1, t=2)
p.energy
p.energy = 5
p.ekin
Check out for builtin decorators or from many modules (https://github.com/lord63/awesome-python-decorator):
import random
def monte_carlo_pi(nsamples):
acc = 0
for i in range(nsamples):
x = random.random()
y = random.random()
if (x ** 2 + y ** 2) < 1.0:
acc += 1
return 4.0 * acc / nsamples
%time monte_carlo_pi2(100000)
from numba import jit
import random
#Just In Time compilation of the code
#get speed similar to C/Fortran
@jit(nopython=True)
def monte_carlo_pi_jit(nsamples):
acc = 0
for i in range(nsamples):
x = random.random()
y = random.random()
if (x ** 2 + y ** 2) < 1.0:
acc += 1
return 4.0 * acc / nsamples
%time monte_carlo_pi_jit(100000)
%time monte_carlo_pi_jit(100000)