Problem 1 (a): List Operations

Transcription

1 Problem 1 (a): List Operations Task 1: Create a list, L1 = [1, 2, 3,.. N] Suppose we want the list to have the elements 1, 2, 10 range(n) creates the list from 0 to N-1 But we want the list to start from 1 range(start,stop,step) creates a list from start to stop (not including stop with an increment step). Default value of step is 1. Method 1: This is not incorrect, but NOT good style of programming >>> L1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] Method 2: This IS preferred >>> N = 10 >>> L1 = range(1, N+1) Method 3: This is OK but we have an extra slicing operation >>> N = 12 >>> L1 = range(n) >>> L1 = L1[1:-1]

2 Problem 1 (b): List Comprehension or Loops Task 2: Starting from list, L1 = [1, 2, 3,.. N], create two additional lists L2 and L3 with the squares and cubes of elements from L1 i.e., L2 = [1, 4, 9,... ] and L3 = [1, 8, 27,...] We can use list comprehension or loops >>> N = 10 >>> L1 = range(1, N+1) List Comprehension Directly access element (easier): >>> L2 = [elem**2 for elem in L1] >>> L3 = [elem**3 for elem in L1] Access element using the index: >>> L2 = [L1[i]**2 for i in range(len(l1))] >>> L3 = [L1[i]**3 for i in range(len(l1))]

3 Lecture 8 Projects Review Mid-Term Problems 1 and 2 Command-Line Arguments Modules

4 Problem 1 (b): Loops for loop (Note: We have to initialize L2 and L3) >>> L2 = [] >>> L3 = [] >>> for elem in L1:... L2.append(elem**2)... L3.append(elem**3) >>> L2 >>> L3 while loop >>> L2 = [] >>> L3 = [] >>> i = 0 >>> while i < len(l1):... L2.append(L1[i]**2)... L3.append(L1[i]**3)... i += 1 >>> L2 >>> L3

5 Problem 1 (c): Sum of the elements Task 3: Sum of the elements in the list Preferred: Use the built-in function sum >>> sum_l1 = sum(l1) >>> sum_l2 = sum(l2) >>> sum_l3 = sum(l3) If you are using loops (for or while), use a single loop and use the index to compute all the sums). >>> sum_l1 = 0.0 >>> sum_l2 = 0.0 >>> sum_l3 = 0.0 >>> for i in range(len(l1)):... sum_l1 += L1[i]... sum_l2 += L2[i]... sum_l3 += L3[i]

6 for and while for and while are both repetition structures Components: 1) Loop variable or counter 2) Initial value for the loop variable 3) Condition to check for the final value 4) Amount to increment or decrement while loop, we explicitly deal with 1, 2, 3 and 4 >>> i =0 # (1, 2) >>> while i<10: # (3)... print i... i += 1 # (4) for loop handles 1, 2, 3, 4 implicitly >>> for i in range(10):... print i Important point here inside the for loop is you should not do i += 1, it will have no effect

7 Problem 2: for while Loop Transformation for loop >>> for i in range(1,10):... print "i = ", i while loop >>> i = 1 >>> while i<10:... print i =, i... i += 1 We have to initialize the counter in the while loop to 1 because range(1,10) generates a list with elements from 1 to 9

8 Objects Almost everything is an object in Python Object has a name and value Python uses dynamic typing, i.e., the type of the object is determined during program execution ((In C, programmer must declare the type of the object, e.g. int a) Values of some objects can change (mutable), some cannot (immutable) >>> a = 1.0 We create an object in memory. Associate a with the created object >>> a = int(a) Now, we create a new object in memory a 1.0 and bind the variable or the name a with the new object. 1.0 i.e., int is an immutable object a 1

9 Command-Line Arguments Task: We create a list, L, with N elements Inputs: Length of the list, N Output: Data structure, List, L What are the ways of assigning a value to N? Assign a value inside the program Accept it as an input using the raw_input() function # Assign a value to N N = 10 L = range(n) # Or read N in as an input N = raw_input( Number of elements, N? ) N = int(n) L = range(n)

10 Command-Line Arguments In Linux, we make use of command line arguments e.g. ls -l to list all files in a directory Let s create a program, listop.py, in scripting mode that will allow us to input the number of list elements, N as a commandline argument i.e., When we execute the script, we can provide N as a command line argument after the program name as follows: $./listop.py 10

11 Command-Line Arguments (Example) We have to import sys module sys module has a list argv containing all the command-line arguments to the program i.e., when you execute the script: argv[0] always stores the program name, argv[1] stores the first argument. $./listop.py 10 argv[0] argv[1] # Program Name: listop.py #!/usr/bin/python from sys import * N = argv[1] N = int(n) L = range(n) print L

12 Command-Line Arguments (extending the example) Task: Let s extend the previous example to access an element at an index given by the variable, choice Inputs: Length of the list, N and index variable, choice Output: List element at index choice Data structure to be processed: List, L Without command-line arguments, there are two options: Assign inputs inside the program Accept inputs using the raw_input() function N = 10 # or N = int(raw_input( Number of elements? )) L = range(n) choice = 2 # or choice = int(raw_input( Which element to access? )) choice = int(choice) element = L[choice]

13 Two Command-Line Arguments (example) We import sys module as before In this case, argv[1] stores N, argv[2] stores choice #listop.py with two command-line arguments #!/usr/bin/python from sys import * print argv N = argv[1] N = int(n) L = range(n) $./listop.py 10 1 print L choice = argv[2] argv[0] argv[1] argv[2] choice = int(choice) element = L[choice]

14 Modules A Python program file is a module and modules import other modules Module example (Just an example, the math module is written in C): # Built-in module: math.py def sqrt(..): def sin(..): Either import all functions: >>> from math import * >>> sqrt(1) Or import the module and access individual functions: >>> import math and access each function as >>> math.sqrt(argument) >>> math.cos(argument)

15 Creating Modules Code Reuse Suppose we want to reuse a function in a program, prog.py Easiest way is to copy and paste it in prog.py Any improvements or debugging of the function, do them in prog.py But, we need to update all the instances of the function used in other programs Create a module that we can reuse in different programs Partition System Namespace Provide a container for names (functions, variables), i.e., the names only belong to a module unless you explicitly import it Each module get its own namespace Shared Data For global objects that are shared by many files, just import the module in all the files instead of defining them in each file

16 Module Example # Module file, mymod.py def writedata(text): print text # Top-level file, top.py import mymod mymod.writedata( test ) Top-level file is mymod.py that contains the main program Import the module, mymod.py so the top-level file can gain access to the objects in mymod.py object.attribute notation is used where the module is the object and you are fetching the object s attributes, in this case, the function

17 Module Example Extended (Just import) # Module file, mymod.py def writedata(text): print text # Module file, mynewmod.py def writedata(text): print text+ message # Top-level file, top.py import mymod import mynewmod mymod.writedata( test ) mynewmod.writedata( test ) Create and import the new module, mynewmod.py where we define the writedata function again but slightly modified

18 Module Example Extended (Import using *) # Module file, mymod.py def writedata(text): print text # Module file, mynewmod.py def writedata(text): print text+ message # Top-level file, top.py from mymod import * from mynewmod import * writedata( test ) writedata( test ) What is the result of the above program? If you have functions or variables (i.e., attributes) with the same names in two modules, you should use the object.attribute notation