Intro to Python Programming Language

2  Introduction  Python Basics  Python Decision Making  Python Loops  Python Sequence Types  Python Functions  Python File I/O Outline

3 Introduction  Python is a clear and powerful object-oriented programming language.  Uses an elegant syntax, making the programs you write easier to read.  Comes with a large standard library that supports many common programming tasks.  Python's interactive mode makes it easy to test short snippets of code.  Runs on many different computers and operating systems: Windows, MacOS, many brands of Unix, OS/2.  Is free software in two senses. It doesn't cost anything to download or use Python, or to include it in your application. Python can also be freely modified and re-distributed.

5 A Code Sample x = 34 – 23 # A comment y = “Hello” # Another one. z = 3.45 if z == 3.45 or y == “Hello”: x = x + 1 y = y + “ World” # String concat. print x print y

6 Enough to Understand the Code  Assignment uses = and comparison uses ==.  For numbers + - * / % are as expected.  Special use of + for string concatenation.  Special use of % for string formatting (as with printf in C)  Logical operators are words (and, or, not) not symbols  The basic printing command is “print”  The first assignment to a variable creates it.  Variables types don’t need to be declared.  Python figures out the variables types on its own.

7 Whitespace  Whitespace is meaningful in Python: especially indentation and placement of newlines.  Use a newline to end a line of code.  Use ‘’ when must go to next line prematurely  No braces { } to mark blocks of code in Python…  Use consistent indentation instead.  The first line with less indentation is outside of the block  The first line with more indentation starts a nested block.  Often a colon appears at the start of a new block. (Eg. For function and class definitions.)

8 Comments  Start comments with # - the rest of line is ignored.  Can include a “documentation string” as the first line of any new function or class that you define.  The development environment, debugger, and other tools use it: it’s good style to include one. def my_function(x, y): “””This is the docstring. This function does …..””” # The code would go here…

9 Assignment Statements  Binding a variable in Python means setting a name to hold a reference to some object.  Assignment creates references, not copies.  Names in Python do not have an intrinsic type. Objects have types.  A reference is deleted via garbage collection after any names bound to it have passed out of scope.

10 Multiple Assignment  One can also assign to multiple names at the same time. >>> x, y = 2, 3 >>> x 2 >>> y 3

11 Naming Rules  Names are case sensitive and cannot start with a number. They can contain letters, numbers, and underscores.  Bob bob _bob _2_bob_ bob_2 BoB  There are some reserved words. Those words cannot be used to label identifiers in a Python program.

12 Variables in Python  A variable stores a piece of data, and gives it a specific name.  Python is a dynamically typed language.  Variables need not be declared in Python before using them.  Variables can be used on the fly and Python infers its type based on the value stored by the variable.  Example: Set the variable “age” equal to the value 20. >>> age = 20  Now “age” can be used in any arithmetic operations, such as, >>> age_after_10 = age + 10 # 30

13 Basic Data Types  Python supports the usual data types, such as,  Integers  Floats  Strings  If both operands are of type int, floor division is performed and an int is returned.  If either operand is a float, classic division is performed and a float is returned.  In addition to int and float, Python supports other types of numbers, such as Decimal, Fraction and Complex numbers.

14 Fun with Python Arithmetic >>> 17 / 3 # int / int -> int 5 >>> 17 / 3.0 # int / float -> float 5.666666666666667 >>> 17 % 3 # the % operator returns the remainder 2 >>> 5 ** 2 # 5 squared 25

15 Python Strings  Besides numbers, Python can also manipulate strings, which can be expressed in several ways.  Strings can be enclosed in single quotes ('...') or double quotes ("…").  The string is enclosed in double quotes if the string contains a single quote and no double quotes, otherwise it is enclosed in single quotes.  String literals can span multiple lines. One way is using triple-quotes: """...""" or '''...'''.  Strings can be concatenated (glued together) with the + operator, and repeated with *. >>> 3 * ‘un’ + ‘ium’ ‘unununium’

16 String Examples >>> 'doesn't' # use ' to escape the single quote... "doesn't" >>> "doesn't" # ...or use double quotes instead "doesn't" >>> '"Isn't," she said.' '"Isn't," she said.' >>> print '"Isn't," she said.' "Isn't," she said.

17 Strings Continued…  Strings can be indexed (subscripted), with the first character having index 0.  There is no separate character type; a character is simply a string of size one.  Indices may also be negative numbers, while counting from the right.  Say, word = ‘Python’ >>> word[-1] # last character ‘n’ >>> word[-2] # second last character ‘o’

18 Strings Continued…  In addition to indexing, slicing is also supported. While indexing is used to obtain individual characters, slicing allows you to obtain a substring.  In slicing, the start is always included, and the end always excluded. This makes sure that s[:i] + s[i:] is always equal to s.

19 Python Decision Making: if, if…else, if…elif…else

20 Python Decision Structures  Decision making is anticipation of conditions occurring while execution of the program and specifying actions taken to the conditions.  Decision structures evaluate multiple expressions which produce TRUE or FALSE as outcome.  Python programming language assumes any non-zero and non-null values as TRUE, and if it is either zero or null, then it is assumed as FALSE value.  If the suite of an if clause consists of a single line, it may go on the same line as the header statement.

21 If in Action… #!/usr/bin/python var = 100 if var == 100: print “Value of expression is 100” print “Good Bye!”

22 Loops In Python: while, for…in, nested loops

23 Loop Statements  Programming languages provide various control structures that allow for more complicated execution paths.  A loop statement allows us to execute a statement or group of statements multiple times.  Python provides the following looping constructs:  While loop  For loop  Loop Control Statements change execution from its normal sequence. When execution leaves a scope, all automatic objects that were created in that scope are destroyed.  Eg:. Break, continue, pass.

24 While Loop  A while loop statement in Python, repeatedly executes a target statement as long as a given condition is true.  Syntax: while expression: statement(s) Eg: #!/usr/bin/python count = 0 while count < 9: print “The count is:”, count count = count + 1

25 For loop  It has the ability to iterate over the items of any sequence, such as list or a string.  Syntax: for iterating_var in sequence: statement(s)  If a sequence contains an expression list, it is evaluated first. Then, the first item in the sequence is assigned to the iterating varaiable iterating_var.  Each item in the sequence is iterated over, until the entire sequence is exhausted.

26 For loop in action… ● Eg:. #!usr/bin/python for letter in ‘Python’: # First Example print ‘Current letter:’, letter Fruits = [‘banana’, ‘apple’, ‘mango’] for fruit in fruits: # Second Example print “Current Fruit:”, fruit

27 Iterating by sequence index  An alternative way of iterating through each item is by index offset into the sequence itself.  Eg:. fruits = [“banana”, “apple”, “mango”] for index in range(len(fruits)): print “Current fruit:”, fruits[index]  In the above example, we took assistance of the len() built-in function, which provides the total number of elements in the tuple as well as the range() built-in function to give us the actual sequence to iterate over.

28 Using else statements with Loops  Python supports to have an else statement associated with a loop  If the else statement is used with a for loop, the else statement is executed when the loop has exhausted the sequence.  If the else statement is used with a while loop, the else statement is executed when the condition becomes false.

29 Else with loops Example ● The following example illustrates the combination of an else statement with statement that searches for prime numbers from 10 through 20. for num in range(10, 20): # to iterate between 10 to 20 for i in range(2, num): # to iterate on the factors of the number if num % i == 0: # To determine the first factor j = num / i # To calculate the second factor print ‘%d equals %d * %d’ % (num, i, j) break else: print num, ‘is a prime number’

30 Sequence Types: Tuples, Lists, and Strings

31 Sequence Types  Tuple  A simple immutable ordered sequence of items  Items can be of mixed types, including collection types  Strings  Immutable  Conceptually very much like a tuple  List  Mutable ordered sequence of items of mixed types.

32 Similar Syntax  All three sequence types (tuples, strings, and lists) share much of the same syntax and functionality.  Key Difference: Tuples and strings are immutable Lists are mutable  The operations shown in this section can be applied to all sequence types  Most examples will just show the operation performed on one.

33 Sequence Types 1  Tuples are defined using parentheses (and commas). >>> tu = (23, ‘abc’, 4.56, (2,3), ‘def’)  Lists are defined using square brackets (and commas). >>> li = [“abc”, 34, 4.34, 23]  Strings are defined using quotes (“, ‘, or “””). >>> st = “Hello World” >>> st = ‘Hello World’ >>>st = “””This is a multi-line string that uses triple quotes.”””

34 Sequence Types 2  We can access individual members of a tuple, list, or string using square bracket “array” notation.  Note that all are 0 based… >>> tu[1] # Second item in the tuple. ‘abc’ >>> li[1] # Second item in the list. 34 >>> st[1] # Second character in string. ‘e’

35 Positive and Negative Indices >>> t = (23, ‘abc’, 4.56, 2,3), ‘def’)  Positive index: count from left, starting with 0. >>> t[1] ‘abc’  Negative lookup: count from right, starting with -1. >>> t[-3] 4.56

36 Slicing: Return Copy of a Subset 1 >>> t = (23, ‘abc’, 4.56, (2,3), ‘def’)  Return a copy of the container with a subset of the original members. Start copying at the first index, and stop copying before the second index. >>> t[1:4] (‘abc’, 4.56, (2,3))  You can also use negative indices when slicing. >>> t[1:-1] (‘abc’, 4.56, (2,3))

37 Slicing: Return Copy of a Subset 2 >>> t = (23, ‘abc’, 4.56, (2,3), ‘def’)  Omit the first index to make a copy starting from the beginning of the container. >>> t[:2] (23, ‘abc’)  Omit the second index to make a copy starting at the first index and going to the end of the container. >>> t[2:] (4.56, (2,3), ‘def’)

38 Copying the Whole Sequence  To make a copy of an entire sequence, you can use [:]. >>> t[:] (23, ‘abc’, 4.56, (2,3), ‘def’)  Note the difference between these two lines for mutable sequences: >>> list2 = list1 # 2 names refer to 1 ref # Changing one affects both >>> list2 = list1[:] # Two independent copies, two refs

39 The ‘in’ Operator  Boolean test whether a value is inside a container: >>> t = [1, 2, 3, 4, 5] >>> 3 in t False >>> 4 in t True >>> 4 not in t False

40 ‘in’ Operator Continued…  For strings, tests for substrings >>> a = ‘abcde’ >>> ‘c’ in a True >>> ‘cd’ in a True >>> ‘ac’ in a False  Be careful: the in keyword is also used in the syntax of for loops and list comprehensions.

41 The + Operator  The + operator produces a new tuple, list, or string whose value is the concatenation of its arguments. >>> (1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) >>> [1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] >>> “Hello” + “ “ + “World” ‘Hello World’

42 The * Operator  The * operator produces a new tuple, list, or string that “repeats” the original content. >>> (1, 2, 3) * 3 (1, 2, 3, 1, 2, 3, 1, 2, 3) >>> [1, 2, 3] * 3 [1, 2, 3, 1, 2, 3, 1, 2, 3] >>> “Hello” * 3 ‘HelloHelloHello’

43 Mutability: Tuples vs. Lists

44 Tuples: Immutable >>> t = (23, ‘abc’, 4.56, (2,3), ‘def) >>> t[2] = 3.14 You can’t change a tuple.  You can make a fresh tuple and assign its reference to a previously used name. >>> t = (23, ‘abc’, 3.14, (2,3), ‘def’)

45 Lists: Mutable >>> li = [‘abc’, 23, 4.34, 23] >>> li[1] = 45 >>> li [‘abc’, 45, 4.34, 23] We can change lists in place. Name li still points to the same memory reference when we’re done. The mutability of lists means that they aren’t as fast as tuples.

46 Operations on lists Only 1 >>> li = [1, 11, 3, 4, 5] >>> li.append(‘a’) # Our first exposure to method syntax >>> li [1, 11, 3, 4, 5, ‘a’] >>> li.insert(2, ‘i’) >>> li [1, 11, ‘i’, 3, 4, 5, ‘a’]

47 The extend method vs the + operator  ‘+’ creates a fresh list (with a new memory reference)  Extend operates on list li in place. >>> li.extend([9, 8, 7]) >>> li [1, 2, ‘i’, 3, 4, 5, ‘a’, 9, 8, 7]  Confusing: • Extend takes a list as an argument. • Append takes a singleton as an argument. >>> li.append([10, 11, 12])

48 Operations on Lists Only 3 >>> li = [‘a’, ‘b’, ‘c’, ‘b’] >>> li.index(‘b’) # index of first occurrence 1 >>> li.count(‘b’) # number of occurences 2 >>> li.remove(‘b’) # remove first occurrence >>> li [‘a’, ‘c’, ‘b’]

49 Operations on Lists Only 4 >>> li = [5, 2, 6, 8] >>> li.reverse() # reverse the list *in place* >>> li [8, 6, 2, 5] >>> li.sort() # sort the list *in place* >>> li [2, 5, 6, 8] >>> li.sort(some_function) # sort in place using user-defined comparison

50 Tuples vs. Lists  Lists slower but more powerful than tuples.  Lists can be modified, and they have lots of handy operations we can perform on them.  Tuples are immutable and have fewer features.  To convert between tuples and lists use the list() and tuple() functions: >>> li = list(tu) >>> tu = tuple(li)

51 Python Dictionary  Each key is separated from its value by a colon ( : ), the items are separated by commas, and the whole thing is enclosed in curly braces.  An empty dictionary without any items is written with just two curly braces, like this { }.  Keys are unique within a dictionary while values my not be.  The values can be of any type, but the keys must be of an immutable data type such as strings, numbers, or tuples.

52 Accessing Values in a Dictionary  To access dictionary elements, we can use the familiar square brackets along with the key to obtain its value. Eg:. dict = {‘Name’: ‘Zara’, ‘Age’: 7, ‘Class’: ‘First’} print dict[‘Name’] print dict[‘Age’]  If we attempt to access a data item with a key, which is not part of the dictionary, we will get an error.

53 Updating Dictionary  We can update a dictionary by adding a new entry or key-value pair, modifying an existing entry, or deleting an existing entry. Eg:. dict = {‘Name’: ‘Zara’, ‘Age’: 7, ‘Class’: ‘First’} dict[‘Age’] = 8 # Update existing entry dict[‘School’] = “DPS School” # Add new entry

54 Delete Dictionary Elements  We can either remove individual dictionary elements or clear the entire contents of a dictionary.  We can also delete the entire dictionary in a single operation.  To explicitly remove an entire dictionary, just use the del statement. dict = {‘Name’: ‘Zara’, ‘Age’: 7, ‘Class’: ‘First’} del dict[‘Name’] # Delete an element dict.clear() # Clear the contents of the dictionary del dict # Remove the entire dictionary structure.

55 Python Functions: code organization and reusability

56 Function as a Concept  A function is a block of organized, reusable code that is used to perform a single, related action.  Functions provide better modularity for an application and a high degree of code reusing.  Python gives us may built-in functions like print(), etc.  We can also create our own functions. These are called user-defined functions.

57 Defining a Function  Function blocks begin with the keyword def followed by the function name and parentheses.  Any input parameters or arguments should be placed within these parentheses. We can also define parameters inside these parentheses.  The first statement of a function can be an optional statement – the documentation string of the function or docstring.  The code block within every function starts with a colon ( : ) and is indented.  The statement return [expression] exits a function, optionally passing back an expression to the caller. A return statement with no arguments is the same as return None.

58 Function Structure def function_name ( parameters ): “function_docstring” function_suite return [expression] Eg:. def printme (str): “This prints a passed string into this function” print str return

59 Function Arguments  Required arguments are the arguments passed to a function in correct positional order. Here, the number of arguments in the function call should match exactly with the function definition.  Keyword arguments are related to the function calls. When we use keyword arguments in a function call, the caller identifies the arguments by the parameter name.  Default arguments are arguments that assume a default value if a value is not provided in the function call for that argument.  When we may need to process a function for more arguments than we specified while defining the function, we use variable-length arguments. They are also known as splat-arguments

60 Python files I/O: input and output with persistence

61 Python File Manipulation  Python provides basic functions and methods necessary to manipulate files by default.  Most of the file manipulation is done using a file object.  The various file handling methods supported are: open() close() write() read() tell()

62 The open() Function  Before we can read or write to a file, we have to open it.  This function creates a file object, which would be utilized to call other support methods associated with it.  Syntax: file_object = open(file_name [, access_mode][, buffering])  The commonly used access modes are ‘r’, ‘rb’, ‘r+’, ‘rb+’, ‘w’, ‘wb’, ‘w+’, ‘wb+’ and ‘a’.  Eg:. fo = open(“foo.txt”, “wb”)

63 The close() Method  The close() method of a file object flushes any unwritten information and closes the file object, after which no more I/O can be done.  Python automatically closes a file when the reference object of a file is reassigned to another file.  Syntax: file_object.close()

64 The write() Method  The write() method writes any string to an open file. It is important to note that Python strings can have binary data and not just text.  The write() method does not add a newline character(‘n’) to the end of the string.  Syntax: File_object.write(string)

65 The read() Method  The read() method reads a string from an open file.  Syntax: file_object.read ( [count] )  Here, the passed parameter is the number of bytes to be read from the opened file.  This method starts reading from the beginning of the file and if count is missing, then it tries to read as much as possible, maybe until the end of file.

66 An Example… fo = open(“foo.txt”, “r+”) # Open a file str = fo.read(10) print “Read string is: “, str position = fo.tell() # Check current position print “Current file position: “, position position = fo.seek(0,0) # Reposition pointer to the beginning str = fo.read(10) print “Again read string is: “, str fo.close()

67 Renaming and Deleting Files  Python os module provides methods that helps us perform file-processing operations, such as renaming and deleting files.  To use this module, we need to import it first and then only we can call any related functions.  Rename Method – os.rename (curr_file_name, new_file_name)  Remove Method – os.remove (file_name)  In order to import a module, we just type: import module_name

68 Directory Manipulation in Python  The os module has several methods that help us create, remove and change directories.  Some of the commonly used methods are:  mkdir() - os.mkdir(“dir_name”)  chdir() - os.chdir(“new_dir)  getcwd() – os.getcwd()  rmdir() – os.rmdir(‘dir_name’)

Intro to Python Programming Language

More Related Content

What's hot

Viewers also liked

Similar to Intro to Python Programming Language

Recently uploaded

Intro to Python Programming Language