Survey
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
Introduction to Python Why Python? Python is a general-purpose interpreted, interactive, object-oriented, and high-level programming language. It was created by Guido van Rossum during 1985- 1990. Like Perl, Python source code is also available under the GNU General Public License (GPL). Have your cake and eat it, too: Productivity and readable code VHLLs will gain on system languages (John Ousterhout) "Life's better without braces" (Bruce Eckel) Python is Interpreted: Python is processed at runtime by the interpreter. You do not need to compile your program before executing it. This is similar to PERL and PHP. Python is Interactive: You can actually sit at a Python prompt and interact with the interpreter directly to write your programs. Python is Object-Oriented: Python supports Object-Oriented style or technique of programming that encapsulates code within objects. Python is a Beginner's Language: Python is a great language for the beginner-level programmers and supports the development of a wide range of applications from simple text processing to WWW browsers to games. Tutorial Outline interactive "shell" basic types: numbers, strings container types: lists, dictionaries, tuples variables control structures functions & procedures classes & instances modules & packages exceptions files & standard library $sudo apt-get install python3-minimal Interactive “Shell” In the bash shell (Linux): type export PYTHONPATH=/usr/local/bin/python3.4 and press Enter. Great for learning the language Great for experimenting with the library Unix: IDLE is the very first Unix IDE for Python. Great for testing your own modules Two variations: IDLE (GUI), python (command line) Type statements or expressions at prompt: >>> print "Hello, world" Hello, world >>> x = 12**2 >>> x/2 72 >>> # this is a comment #!/usr/bin/python3 print ("Hello, Python!") Python supports four different numerical types − Numbers The usual suspects 12, 3.14, 0xFF, 0377, (-1+2)*3/4**5, abs(x), 0<x<=5 C-style shifting & masking 1<<16, x&0xff, x|1, ~x, x^y Integer division truncates :-( 1/2 -> 0 # 1./2. -> 0.5, float(1)/2 -> 0.5 Will be fixed in the future Long (arbitrary precision), complex 2L**100 -> 1267650600228229401496703205376L In Python 2.2 and beyond, 2**100 does the same thing 1j**2 -> (-1+0j) int (signed integers): They are often called just integers or ints, are positive or negative whole numbers with no decimal point. long (long integers ): Also called longs, they are integers of unlimited size, written like integers and followed by an uppercase or lowercase L. float (floating point real values) : Also called floats, they represent real numbers and are written with a decimal point dividing the integer and fractional parts. Floats may also be in scientific notation, with E or e indicating the power of 10 (2.5e2 = 2.5 x 102 = 250). complex (complex numbers) : are of the form a + bJ, where a and b are floats and J (or j) represents the square root of -1 (which is an imaginary number). The real part of the number is a, and the imaginary part is b. Complex numbers are not used much in Python programming. Strings Operator Description Example + a + b will give HelloPython * "hello"+"world" "helloworld" # concatenation "hello"*3 "hellohellohello" # repetition "hello"[0] "h" # indexing "hello"[-1] "o" # (from end) "hello"[1:4] "ell" # slicing len("hello") 5 # size "hello" < "jello" 1 "e" in "hello" # comparison 1 [] [:] in not in r/R # search "escapes: \n etc, \033 etc, \if etc" 'single quotes' """triple quotes""" r"raw strings" % Concatenation - Adds values on either side of the operator Repetition - Creates new strings, concatenating multiple copies of the same string Slice - Gives the character from the given index Range Slice - Gives the characters from the given range Membership - Returns true if a character exists in the given string Membership - Returns true if a character does not exist in the given string Raw String - Suppresses actual meaning of Escape characters. The syntax for raw strings is exactly the same as for normal strings with the exception of the raw string operator, the letter "r," which precedes the quotation marks. The "r" can be lowercase (r) or uppercase (R) and must be placed immediately preceding the first quote mark. Format - Performs String formatting a*2 will give -HelloHello a[1] will give e a[1:4] will give ell H in a will give 1 M not in a will give 1 print r'\n' prints \n and print R'\n'prints \n Lists Flexible arrays, not Lisp-like linked lists a = [99, "bottles of beer", ["on", "the", "wall"]] Same operators as for strings a+b, a*3, a[0], a[-1], a[1:], len(a) Item and slice assignment a[0] = 98 a[1:2] = ["bottles", "of", "beer"] -> [98, "bottles", "of", "beer", ["on", "the", "wall"]] del a[-1] # -> [98, "bottles", "of", "beer"] The method append() appends a passed obj into the existing list. Syntax Following is the syntax for append() method − list.append(obj) Parameters obj -- This is the object to be appended in the list. Return Value This method does not return any value but updates existing list. Example The following example shows the usage of append() method. #!/usr/bin/python aList = [123, 'xyz', 'zara', 'abc']; aList.append( 2009 ); print "Updated List : ", aList When we run above program, it produces following result − Updated List : [123, 'xyz', 'zara', 'abc', 2009] More List Operations >>> a = [0,1,2,3,4] ; >>> a.append(5) # [0,1,2,3,4,5] >>> a.pop() # [0,1,2,3,4] 5 >>> a.insert(0, 42) # [42,0,1,2,3,4] >>> a.pop(0) # [0,1,2,3,4] 5.5 >>> a.reverse() # [4,3,2,1,0] >>> a.sort() # [0,1,2,3,4] Dictionaries Hash tables, "associative arrays" d = {"duck": "eend", "water": "water"} Lookup: d["duck"] -> "eend" d["back"] # raises KeyError exception Delete, insert, overwrite: del d["water"] # {"duck": "eend", "back": "rug"} d["back"] = "rug" # {"duck": "eend", "back": "rug"} d["duck"] = "duik" # {"duck": "duik", "back": "rug"} More Dictionary Ops Keys, values, items: d.keys() -> ["duck", "back"] d.values() -> ["duik", "rug"] d.items() -> [("duck","duik"), ("back","rug")] Presence check: d.has_key("duck") -> 1; d.has_key("spam") -> 0 Values of any type; keys almost any {"name":"Guido", "age":43, ("hello","world"):1, 42:"yes", "flag": ["red","white","blue"]} Dictionary Details Keys must be immutable: numbers, strings, tuples of immutables these cannot be changed after creation reason is hashing (fast lookup technique) not lists or other dictionaries these types of objects can be changed "in place" no restrictions on values Keys will be listed in arbitrary order again, because of hashing Tuples A tuple is a sequence of immutable Python objects. Tuples are sequences, just like lists. The differences between tuples and lists are, the tuples cannot be changed unlike lists and tuples use parentheses, whereas lists use square brackets. tup1 = ('physics', 'chemistry', 1997, 2000); tup2 = (1, 2, 3, 4, 5 ); tup3 = "a", "b", "c", "d"; key = (lastname, firstname) point = x, y, z # parentheses optional x, y, z = point # unpack lastname = key[0] singleton = (1,) # trailing comma!!! empty = () # parentheses! tuples vs. lists; tuples immutable Variables No need to declare Need to assign (initialize) use of uninitialized variable raises exception Not typed if friendly: greeting = "hello world" else: greeting = 12**2 print greeting Everything is a "variable": Even functions, classes, modules Reference Semantics Assignment manipulates references x = y does not make a copy of y x = y makes x reference the object y references Very useful; but beware! Example: >>> a = [1, 2, 3] >>> b = a >>> a.append(4) >>> print b [1, 2, 3, 4] Changing a Shared List a = [1, 2, 3] a 1 2 3 1 2 3 1 2 3 a b=a b a a.append(4) b 4 Changing an Integer a=1 a 1 a b=a 1 b a new int object created by add operator (1+1) 2 a = a+1 b 1 old reference deleted by assignment (a=...) Control Structures if condition: statements while condition: statements [elif condition: statements] ... else: for var in sequence: statements statements break continue Grouping Indentation In C: In Python: for (i = 0; i < 20; i++) { for i in range(20): if (i%3 == 0) { printf("%d\n", i); if i%3 == 0: if (i%5 == 0) { print i printf("Bingo!\n"); } if i%5 == 0: } print "Bingo!" print "---" printf("---\n"); } 0 Bingo! ------3 ------6 ------9 ------12 ------15 Bingo! ------18 ----- Functions, Procedures def name(arg1, arg2, ...): """documentation""" # optional doc string statements return # from procedure return expression # from function Example Function def gcd(a, b): "greatest common divisor" while a != 0: a, b = b%a, a # parallel assignment return b >>> gcd.__doc__ 'greatest common divisor' >>> gcd(12, 20) 4 Classes class name: "documentation" statements -orclass name(base1, base2, ...): ... Most, statements are method definitions: def name(self, arg1, arg2, ...): ... May also be class variable assignments Example Class class Stack: "A well-known data structure…" def __init__(self): # constructor self.items = [] def push(self, x): self.items.append(x) # the sky is the limit def pop(self): x = self.items[-1] # what happens if it’s empty? del self.items[-1] return x def empty(self): return len(self.items) == 0 # Boolean result Using Classes To create an instance, simply call the class object: x = Stack()# no 'new' operator! To use methods of the instance, call using dot notation: x.empty() # -> 1 x.push(1) # [1] x.empty() # -> 0 x.push("hello") x.pop() # [1, "hello"] # -> "hello" # [1] To inspect instance variables, use dot notation: x.items # -> [1] Subclassing class FancyStack(Stack): "stack with added ability to inspect inferior stack items" def peek(self, n): "peek(0) returns top; peek(-1) returns item below that; etc." size = len(self.items) assert 0 <= n < size return self.items[size-1-n] # test precondition Subclassing (2) class LimitedStack(FancyStack): "fancy stack with limit on stack size" def __init__(self, limit): self.limit = limit FancyStack.__init__(self) # base class constructor def push(self, x): assert len(self.items) < self.limit FancyStack.push(self, x) # "super" method call Class / Instance Variables class Connection: verbose = 0 # class variable def __init__(self, host): self.host = host # instance variable def debug(self, v): self.verbose = v # make instance variable! def connect(self): if self.verbose: # class or instance variable? print "connecting to", self.host Instance Variable Rules On use via instance (self.x), search order: (1) instance, (2) class, (3) base classes this also works for method lookup On assignment via instance (self.x = ...): always makes an instance variable Class variables "default" for instance variables But...! mutable class variable: one copy shared by all mutable instance variable: each instance its own Modules Collection of stuff in foo.py file functions, classes, variables Importing modules: import re; print re.match("[a-z]+", s) from re import match; print match("[a-z]+", s) Import with rename: import re as regex from re import match as m Before Python 2.0: import re; regex = re; del re Packages Collection of modules in directory Must have __init__.py file May contain subpackages Import syntax: from P.Q.M import foo; print foo() from P.Q import M; print M.foo() import P.Q.M; print P.Q.M.foo() import P.Q.M as M; print M.foo() # new Catching Exceptions def foo(x): return 1/x def bar(x): try: print foo(x) except ZeroDivisionError, message: print "Can’t divide by zero:", message bar(0) Try-finally: Cleanup f = open(file) try: process_file(f) finally: f.close() # always executed print "OK"# executed on success only Raising Exceptions raise IndexError raise IndexError("k out of range") raise IndexError, "k out of range" try: something except: # catch everything print "Oops" raise # reraise More on Exceptions User-defined exceptions subclass Exception or any other standard exception Old Python: exceptions can be strings WATCH OUT: compared by object identity, not == Last caught exception info: sys.exc_info() == (exc_type, exc_value, exc_traceback) Last uncaught exception (traceback printed): sys.last_type, sys.last_value, sys.last_traceback Printing exceptions: traceback module File Objects f = open(filename[, mode[, buffersize]) mode can be "r", "w", "a" (like C stdio); default "r" append "b" for text translation mode append "+" for read/write open buffersize: 0=unbuffered; 1=line-buffered; buffered methods: read([nbytes]), readline(), readlines() write(string), writelines(list) seek(pos[, how]), tell() flush(), close() fileno() Standard Library Core: os, sys, string, getopt, StringIO, struct, pickle, ... Regular expressions: re module; Perl-5 style patterns and matching rules Internet: socket, rfc822, httplib, htmllib, ftplib, smtplib, ... Miscellaneous: pdb (debugger), profile+pstats Tkinter (Tcl/Tk interface), audio, *dbm, ... Python 2.0: What's New Augmented assignment: x += y List comprehensions: [s.strip() for s in f.readlines()] Extended print: print >>sys.stderr, "Hello!" Extended import: import foo as bar Unicode strings: u"\u1234" New re implementation (faster, Unicode) Collection of cyclic garbage XML, distutils URLs http://www.python.org official site http://starship.python.net Community http://www.python.org/psa/bookstore/ (alias for http://www.amk.ca/bookstore/) Python Bookstore Further Reading Learning Python: Lutz, Ascher (O'Reilly '98) Python Essential Reference: Beazley (New Riders '99) Programming Python, 2nd Ed.: Lutz (O'Reilly '01) Core Python Programming: Chun (Prentice-Hall '00) The Quick Python Book: Harms, McDonald (Manning '99) The Standard Python Library: Lundh (O'Reilly '01) Python and Tkinter Programming: Grayson (Manning '00) Python Programming on Win32: Hammond, Robinson (O'Reilly '00) Learn to Program Using Python: Gauld (Addison-W. '00) And many more titles... The Problem The Subaru Software Development team (SSD) is migrating their instrument control software from C/C++ to Python. Lack of performance comparisons directly between the two languages. Information on performance impacts from migrated code is needed. 40 Write performance benchmarking software in both C/C++ and Python. Execute software on Subaru’s Real Time System (AO188RTS) Construct a Wiki page on Subaru’s Wiki to present an analysis on the results. 41 Why Python? C++ Complex syntax Difficult to read Python Minimal Syntax Easier to read and debug Faster development time Increases productivity Compiled vs. Interpreted C++ is a compiled language. Code is translated from a human readable text form into an executable form that a machine can read. Compiled code is hardware specific. Python is an interpreted language. Code is translated into a machine readable form during run time by an interpreter application. Interpreted code run on any platform with the interpreter installed. Benchmarking Suite Output GUI Runtime (ms) (Shorter is better) Results - The Good Searching Sorting C++ Python C++ Python 45 Results – The Bad Vector Normalization C++ Python Jitter 46 Results – The Ugly Matrix Inversion C++ Python Jitter 47 Conclusions Python ran an average of 4x slower than C++ in averaging all test results. Runtime jitter is more important for real-time applications than average execution times. Mathematical, memory intensive, or complex algorithms suffer the biggest performance impacts in Python. Utilizing Pythons built in methods or external modules can produce near or better than C++ performance. Exercises Exercise Rewrite your pay computation with time-and-ahalf for overtime and create a function called computepay which takes two parameters ( hours and rate). Enter Hours: 45 Enter Rate: 10 Pay: 475.0 475 = 40 * 10 + 5 * 15 Installing Python Installing your text editor (NotePad++ or TextWrangler) Setting tab expansion Using the Command Line or Terminal Interface Editing and running Python Programs Exercise 2.3 Write a program to prompt the user for their name and welcome them. Enter your name: Chuck Hello Chuck Exercise 2.4 Write a program to prompt the user for hours and rate per hour to compute gross pay. Enter Hours: 35 Enter Rate: 2.75 Pay: 96.25 Exercise 3.1 Rewrite your pay computation to give the employee 1.5 times the hourly rate for hours worked above 40 hours. Enter Hours: 45 Enter Rate: 10 Pay: 475.0 475 = 40 * 10 + 5 * 15 Exercise 3.2 Rewrite your pay program using try and except so that your program handles non-numeric input gracefully. Enter Hours: 20 Enter Rate: nine Error, please enter numeric input Enter Hours: forty Error, please enter numeric input Exercise 5.1 Write a program which reads list of numbers until ``done'' is entered. Once ``done'' is entered, print out the total, count, and average of the numbers. If the user enters anything other than a number, print an error message and skip to the next number. Enter a number: 4 Enter a number: 5 Enter a number: bad data Invalid input Enter a number: 7 Enter a number: done Average: 5.33333333333