Download Bild 1 - Uppsala University

Introduction to
What is Python?
• Dynamic, interpreted high-level language.
• Created in 1991 by Guido van Rossum.
• Design philosophy: Short development time is prioritized
over excecution speed.
• Syntax similar to C++ or Java.
Facts about Python
• Portable, available for all common platforms.
• Python is Open Source and free to use, even for
commercial applications.
• (Relatively) Easy to integrate with other languages, such as
Java, C/C++, Fortran and .NET.
• Designed for multiple paradigms. Both object oriented and
procedural programming are possible.
What is Python good for?
• Internet applications, good support for HTTP, FTP, SMTP
and CGI.
• Integrating components written in a low-level language,
“glue code”.
• Portable system tools, same commands on each platform.
Compare with dir (Windows) and ls (Linux).
• Portable GUI:s.
• Database handling.
• Projects where time of development is more important than
speed of execution.
What is Python not good for?
• Tasks where performance is critical.
• Such tasks can be implemented in C/C++ modules
using tools such as SWIG (www.swig.org).
Python and VTK
• VTK is written in C++, but has bindings to
Python, Java, Tcl ...
• For this workshop, we will use VTK with
Python.
The Python prompt
• Can be used to execute individual Python
commands interactively.
• The prompt has a “memory” which is kept
until the prompt is closed.
• Start the prompt by typing python in a
terminal.
The Python language
•
•
•
•
•
Variables and types
Control structures
Functions
Classes
File handling
Variables
•All variables in Python are references
Variable
Data
Variable names
•May contain english letters, numbers and
underscores.
• Must not start with a number.
Valid names
Invalid names
varname
vArNaMe1
var_name_1
_var_name
påskmust
1_varname
varname 1
var&name
Variable assignment
•A reference is created with=
Creates the following situation:
a
10
b
20
c
30
a = 10
b = 20
c = a + b
More on references
•Multiple references: Many variables can
refer to the same object.
list_a
list_b
list_c
[1, 2, 3]
>>>
>>>
>>>
>>>
>>>
>>>
[1,
list = [1, 2, 3]
list_a = [1, 2, 3]
list_b = list_a
list_c = list_b
list_c[2] = 78
list_a
2, 78]
•Reference counting: An object is deleted
automatically when no variables refer to it.
Datatypes
•
•
•
•
•
•
Numbers
Strings
Boolean types
Lists
Tuples
Others...
Numbers
•Different kinds of
numbers are represented
by different classes:
Integers (int)
Big integers (long)
Real numbers (float)
Complex numbers (complex)
>>> a = 10
>>> a.__class__
<type 'int'>
>>> big_num = 9875628736L
>>> big_num.__class__
<type 'long'>
>>> pi_constant = 3.1415
>>> pi_constant.__class__
<type 'float'>
>>> z = complex(3.4, 8.35)
>>> z
(3.399999999+8.349999999j)
>>> z.__class__
<type 'complex'>
Operations on numbers
• The operations +, -, * and / work as
usual.
• % - Remainder
// - Integer division
** - Power
• abs(x)
int(x)
long(x)
float(x)
complex(a, b)
>>> a = 3.14
>>> b = 5
>>> c = b / a
>>> c.__class__
<type 'float'>
>>> 5 // 2
2
>>> 5 // float(2)
2.0
>>> 5 / float(2)
2.5
>>> b / complex(6, 4)
(0.576923072-0.384615381j)
>>> 2 / 3
0
Strings
• A string is a sequence of
characters.
• A string is created using
single or double quotes.
>>> s1 = "exempeltext"
>>> s2 = 'exempeltext igen'
>>> s3 = "felaktigt'
File "<stdin>", line 1
s3 = "felaktigt'
^
SyntaxError: EOL while scanning
single-quoted string
>>> s4 = s1 + s2
>>> s4
'exempeltextexempeltext igen'
>>> s5 = str(3)
>>> s5
'3'
>>> s5.__class__
<type 'str'>
Boolean types
• The following expressions are
false:
None
False
The number 0
Every empty sequence
Every empty mapping {}
• All other objects are (somewhat
simplified) defined to be true.
>>> a = True
>>> a.__class__
<type 'bool'>
>>> a = 5 > 7
>>> a
False
Lists
• Lists are containers with an arbitrary number of
elements.
• The elements can be any Python object. A single list
can contain objects of many different types.
>>> list = [1, 2, 3]
>>> list
[1, 2, 3]
>>> list_2 = [1, "mixed",
"li"+"st"]
>>> list_2
[1, 'mixed', 'list']
More on lists
• Individual element are accessed with an index within
square brackets [index]. The first element has index 0.
>>> list_2
[1, 'blandad', 'lista']
>>> list_2[1]
'blandad'
>>> list_2[1] = "Nytt element"
>>> list_2
[1, 'Nytt element', 'lista']
Tuples
• Tuples are static lists.
• Tuples have better performance than lists, but are less
flexible.
>>> tuple_1 = (1, 2, 3)
>>> tuple_2 = (1, "mixed")
>>> tuple_2[1]
'mixed'
>>> tuple_2[1] = "New element"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item
assignment
Printing
• The Python command for writing text to the prompt is
print.
>>> print "Hello"
Hello
>>> print "Hello", "world"
Hello world
>>> print 10+3
13
If-statements
>>> a = 10
>>> if a > 5:
...
print "The number is greater than 5"
...
The number is greater than 5
• Note the indentation! In Python, indentation is used to
control which block a statement belongs to. A colon
indicates that a new block of code begins.
else
>>> a = 10
>>> if a < 5:
...
print "a is less than 5"
... else:
...
print "a is greater than or equal to 5"
...
a is greater than or equal to 5
Multiple choices
• Multiple choices are handled with elif.
• Many languages have a case-statement for handling
multiple choices. This was deemed redundant by the
Python developers.
>>> a = 10
>>> if a == 1:
...
print "a is
... elif a == 2:
...
print "a is
... elif a == 3:
...
print "a is
... else:
...
print "a is
...
a is something else
one"
two"
three"
something else"
for-loops
• Again, use indentation to
define a block of code.
>>> for i in range(10):
...
print i
...
0
1
2
3
4
5
6
7
8
9
Nested loops
>>> for i in range(2):
...
for j in range(3):
...
for k in range(4):
...
print "i=%i, j=%i, k=%i" % (i, j, k)
...
i=0, j=0, k=0
i=0, j=0, k=1
i=0, j=0, k=2
i=0, j=0, k=3
i=0, j=1, k=0
i=0, j=1, k=1
...
i=1, j=1, k=2
i=1, j=1, k=3
i=1, j=2, k=0
i=1, j=2, k=1
i=1, j=2, k=2
i=1, j=2, k=3
Beyond the Python prompt
• The python prompt is not suited for larger
programs.
• Python programs are stored in regular text
files.
• Commonly the filenames end with .py, but
this is not required.
Executing Python programs
• Python files are executed using the python
command.
• The search path to this program must be
set.
• On windows, this is set by the system
variable PYTHONPATH.
Python is dynamically typed
# -*- coding: utf-8 -*# a refers to a number
a = 10
print a, a.__class__
# a refers to a string
a = "lkshjdglgv"
print a, a.__class__
# a refers to a list
a = [5, 2, 8, 5]
print a, a.__class__
a.sort()
# a refers to a number again
a = 10
a.sort()
$> python dynamic_binding.py
10 <type 'int'>
lkshjdglgv <type 'str'>
[5, 2, 8, 5] <type 'list'>
Traceback (most recent call last):
File "dynamic_binding.py", line 18, in
<module>
a.sort()
AttributeError: 'int' object has no
attribute 'sort'
Duck Typing:
"when I see a bird that walks like a duck and swims
like a duck and quacks like a duck, I call that bird a
duck."
Python is strongly typed
• No implicit type conversions
>>> a = 3
>>> b = '4'
>>> a + b
Traceback (most recent call
last):
File "<stdin>", line 1, in
<module>
TypeError: unsupported operand
type(s)
for +: 'int' and 'str'
>>> str(a) + b
'34'
>>> a + int(b)
7
Functions in Python
• A function is create using the reserved word def followed
by the function name and a colon.
• The rules for function names are the same as for variable
names.
# function_01.py
def function_a():
print "Detta skrivs inuti funktionen."
print "Detta skrivs först."
function_a() # Funktionen anropas
print "Detta skrivs efter metodanropet."
$> python function_01.py
Detta skrivs först.
Detta skrivs inuti funktionen.
Detta skrivs efter metodanropet.
Function arguments
• We communicate with functions by specifying
arguments in the function call.
# function_02.py
def greeting(name, age):
print """Hej %s. Du är %i år gammal.""" % (name, age)
greeting("Maja", 23)
greeting("Pelle", 31)
$> python function_02.py
Hej Maja. Du är
23 år gammal.
Hej Pelle. Du är
31 år gammal.
Default arguments
• Default arguments can be used to avoid having to
specify all arguments.
# function_03.py
def greeting(name, age=20):
print """Hej %s. Du är %i år gammal.""" % (name, age)
greeting("Maja", 23)
greeting("Pelle")
$> python function_03.py
Hej Maja. Du är
23 år gammal.
Hej Pelle. Du är
20 år gammal.
Order of arguments
• Problems with many arguments: Arguments must
be given in the order given in the function
defintion.
# function_04.py
def greeting(name="Unknown", age=20):
print """Hello %s. You are %i years old.""" % (name, age)
greeting()
greeting("Pelle")
greeting(45) # Gives the wrong result
$> python function_04.py
Hello Unknown. You are 20 years old.
Hello Pelle. You are 20 years old.
Hello 45. You are 20 years old.
Arguments by name
• The solution is to give arguments by name.
# function_05.py
def greeting(name="Okänd", age=20):
print """Hej %s. Du är %i år gammal.""" % (name, age)
greeting()
greeting("Pelle") # Still works
greeting(name="Pelle") # Eqvivalent
greeting(age=45) # Gives the right result
greeting("Maja", 33)
greeting(name = "Maja", age = 33) # Eqvivalent
$> python function_05.py
Hej Okänd. Du är 20 år gammal.
Hej Pelle. Du är 20 år gammal.
Hej Pelle. Du är 20 år gammal.
Hej Okänd. Du är 45 år gammal.
Hej Maja. Du är 33 år gammal.
Hej Maja. Du är 33 år gammal.
Return values
•The return statement is used to return a
value from a function.
# return_values_01.py
def my_own_join(texts, separator=" "):
s = ""
for text in texts:
s += text + separator
s = s[:-len(separator)] + "."
return s
my_text_pieces = ["Detta", "är", "inte",
"så", "meningsfullt"]
print my_own_join(my_text_pieces, "_")
$> python return_values_01.py
Detta_är_inte_så_meningsfullt.
Multiple return values
• Python allows any number of return values.
# return_values_03.py
def min_max(seq):
return min(seq), max(seq)
a = [3, 573, 234, 24]
minimum, maximum = min_max(a)
print minimum, maximum
result = min_max(a)
print result
print result.__class__
$> python return_values_03.py
3 573
(3, 573)
<type 'tuple'>
Modules
• When writing larger programs, it is not practical to
keep all code in the same file.
• In python Modules offer a way to separate large
programs into smaller units.
• Modules are also used to organize functions and
variables into namespaces.
Standard modules
• Python has a number of standard modules that are
always available for import.
• Modules are imported with the import-statement.
>>> sys
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'sys' is not defined
>>> import sys
>>> sys
<module 'sys' (built-in)>
>>> sys.version
'2.4.3 (#1, Dec 11 2006, 11:39:03) \n[GCC 4.1.1 20061130 (Red
Hat 4.1.1-43)]'
3rd party modules
• Lots of freely available modules for:
– GUI:s
– Image Processing
– Computer Graphics
– Web development
– Numerical Computations
– ...
Object oriented programming
• Python is originally a procedural language, with added
support for object orientation.
• Classes are defined using the class keyword:
# -*- coding: utf-8 -*# io_01.py
class MyClass
MyNumer=10
def printNumber(self):
print 'The number is ',MyNumber
#Now we use the class
anObject=MyClass()
anObject.printNumber()
Object oriented programming
• Python is originally a procedural language, with added
support for object orientation.
• Classes are defined using the class keyword:
# -*- coding: utf-8 -*# io_01.py
class MyClass:
MyNumer=10
def printNumber(self):
print 'The number is ',MyNumber
#Now we use the class
anObject=MyClass()
anObject.printNumber()
Private variables
• Python has limited support for private class
variables.
• Variable names starting with two
underscores (“__”) are considered private.
• If you really want to, it is still possible to
access those variables from outside the
class.
File I/O in python
• Files are opened with the open statement
# -*- coding: utf-8 -*# io_01.py
f = open("newfile.txt", "r") # Öppna filen
print f.read() # Läs in hela filen
“r” -read only
“w”- write only
“r+” - read and write
“a” - append data at the end of the file
“b”- binary file
Reading parts of a file
# -*- coding: utf-8 -*# io_01.py
f = open("newfile.txt")
for row in f.readlines():
print row,
f.close()
f = open("newfile.txt")
print f.read(8)
print f.read(5)
$> python io_02.py
Detta är textrad 1.
Detta är textrad 2.
Detta är textrad 3.
Detta är textrad 4.
Detta är
text
Writing to a file
# -*- coding: utf-8 -*# io_03.py
f = open("newfile.txt", "w")
f.write(str(3) + "\n")
f.write(str([1,2,3]) + "\n")
f.write(str({"name":"Kalle"}) + "\n")
f.close()
f = open("newfile.txt", "a")
f.write("Denna rad läggs till.")
f.close()
f = open("newfile.txt")
print f.read()
f.close()
$> python io_03.py
3
[1, 2, 3]
{'name': 'Kalle'}
Denna rad läggs till.
That's it!
• Now you know the basics
• More info: www.python.org