Introduction to Python Why Python? Have your cake and eat it, too: Productivity and readable code Python is a general-purpose interpreted, interactive, object-oriented, and high-level programming language. It was created by VHLLs will gain on system languages Guido van Rossum during 1985- 1990. Like (John Ousterhout) Perl, Python source code is also available under the GNU General Public License (GPL). "Life's better without braces" (Bruce Eckel) Python is Interpreted: Python is processed at Tutorial Outline runtime by the interpreter. You do not need to compile your program before executing it. This is similar to PERL and PHP. interactive "shell" Python is Interactive: You can actually sit at a Python prompt and interact with the basic types: numbers, strings interpreter directly to write your programs. container types: lists, dictionaries, tuples variables Python is Object-Oriented: Python supports Object-Oriented style or technique of control structures programming that encapsulates code functions & procedures within objects. classes & instances Python is a Beginner's Language: Python is a modules & packages great language for the beginner-level exceptions programmers and supports the files & standard library development of a wide range of applications from simple text processing to WWW browsers to games. $sudo apt-get install python3-minimal In the bash shell (Linux): type export PYTHONPATH=/usr/local/bin/python3.4 and press Interactive “Shell” 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: #!/usr/bin/python3 >>> print "Hello, world" print ("Hello, Python!") Hello, world >>> x = 12**2 >>> x/2 72 >>> # this is a comment Python supports four different numerical types − int (signed integers): They are often called just Numbers integers or ints, are positive or negative whole numbers with no decimal point. long (long integers ): Also called longs, they are The usual suspects integers of unlimited size, written like integers and 12, 3.14, 0xFF, 0377, (-1+2)*3/4**5, abs(x), followed by an uppercase or lowercase L. 0<x<=5 C-style shifting & masking float (floating point real values) : Also called floats, 1<<16, x&0xff, x|1, ~x, x^y they represent real numbers and are written with a Integer division truncates :-( decimal point dividing the integer and fractional 1/2 -> 0 # 1./2. -> 0.5, float(1)/2 -> 0.5 parts. Floats may also be in scientific notation, with E Will be fixed in the future or e indicating the power of 10 (2.5e2 = 2.5 x 102 = 250). Long (arbitrary precision), complex 2L**100 -> 1267650600228229401496703205376L complex (complex numbers) : are of the form a + bJ, In Python 2.2 and beyond, 2**100 does the same thing where a and b are floats and J (or j) represents the 1j**2 -> (-1+0j) 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. Operator Description Example Strings + Concatenation - Adds values on a + b will give HelloPython either side of the operator * Repetition - Creates new strings, a*2 will give -HelloHello concatenating multiple copies "hello"+"world" "helloworld" # concatenation of the same string [] Slice - Gives the character from a[1] will give e "hello"*3 "hellohellohello" # repetition the given index [ : ] Range Slice - Gives the a[1:4] will give ell "hello"[0] "h" # indexing characters from the given range in Membership - Returns true if a H in a will give 1 "hello"[-1] "o" # (from end) character exists in the given string "hello"[1:4] "ell" # slicing not in Membership - Returns true if a M not in a will give 1 character does not exist in the len("hello") 5 # size given string r/R Raw String - Suppresses actual print r'\n' prints \n and print "hello" < "jello" 1 # comparison meaning of Escape characters. R'\n'prints \n The syntax for raw strings is "e" in "hello" 1 # search exactly the same as for normal strings with the exception of the "escapes: \n etc, \033 etc, \if etc" raw string operator, the letter "r," which precedes the quotation marks. The "r" can be lowercase 'single quotes' """triple quotes""" r"raw strings" (r) or uppercase (R) and must be placed immediately preceding the first quote mark. % Format - Performs String formatting 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. tup1 = ('physics', 'chemistry', 1997, 2000); The differences between tuples and lists are, tup2 = (1, 2, 3, 4, 5 ); tup3 = "a", "b", "c", "d"; the tuples cannot be changed unlike lists and tuples use parentheses, whereas lists use square brackets. 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 a b = a 1 2 3 b a a.append(4) 1 2 3 4 b Changing an Integer a = 1 a 1 a b = a 1 b new int object created by add operator (1+1) a 2 a = a+1 old reference deleted by assignment (a=...) b 1 Control Structures if condition: while condition: statements statements [elif condition: statements] ... for var in sequence: else: statements statements break continue Grouping Indentation 0 Bingo! In C: --- --- --- 3 In Python: --- for (i = 0; i < 20; i++) --- --- 6 { --- --- for i in range(20): if (i%3 == 0) { --- 9 --- if i%3 == 0: printf("%d\n", i); --- --- if (i%5 == 0) { 12 print i --- --- printf("Bingo!\n"); } --- if i%5 == 0: 15 Bingo! print "Bingo!" } --- --- printf("---\n"); --- print "---" 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 -or- class 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") # [1, "hello"] x.pop()