Coding with Python

Overivew

https://www.youtube.com/user/khanacademy/search?query=python https://pythongisandstuff.wordpress.com/2011/07/12/tutorial-arcpy-basics/ https://developers.google.com/edu/python/set-up#editing-check https://www.e-education.psu.edu/geog485/node/98

http://desktop.arcgis.com/en/arcmap/10.3/analyze/arcpy-mapping/getting-started-with-arcpy-mapping-tutorial.htm http://www.nickeubank.com/wp-content/uploads/2015/10/ArcPy_IntroductoryTutorial.pdf http://gis.dfwinfo.com/presentations/Python.swf http://www.utsa.edu/lrsg/teaching/EES6513-09/L10%20-%20Python.pdf http://people.virginia.edu/~err8n/pythongis/

UNIT 2: Strings and Console output

Creating Strings

• 3 methods
  • `hello world`
  • "hello heaven"
  • str(7)

String methods

• String methods lets you perform tasks on strings, like the following 3 methods
  • parrot.lower() = all to lowercase
  • len(parrot) = length of string
  • str(3) = change non-string to strong
• Dot Notation = only work with strings
  • parrot.lower(),parrot.upper() = only work with strings
  • len(parrot), str(3) = len(), and str() work on other types of data

Basic printing

• print "Bork said the dog"

Advanced printing

• String cocatenation
  • print "Life " + "of " + "Brian" = Life of Brian
• Explicit String Conversion
  • Combine string with something that isn’t a string
  • print "Pikachu has gained " + str(10) + " XP" = convert non-string to string and cocatenate
• String formatting with %
  • Combine string with variable
  • Better than concatenating

  • name = "Premsuke"
    world = "digimon"
    print "Hello %s. Welcome to the world of %s" % (name,world)

  • note: Python 2.6 and up can use .format which is more advanced than %.
    • .format = set value, then replace value in string. uses curly braces {var_name} with var name inside
      

    • "I am a {type}".format(type="string")
      my_name = "Michael"
      "Hello, my name is {name}".format(name=my_name)

• String formatting with % and raw inputs
  • need the same number of %s terms in a string as the number of variables in parentheses:

  • name = raw_input("What is your name?")
    quest = raw_input("What is your quest?")
    color = raw_input("What is your favorite color?")
    print "Ah, so your name is %s, your quest is %s, " \
    "and your favorite color is %s." % (name, quest, color)

UNIT 2: Date and Time

• Practice concepts introduced in Strings Unit

datetime library

• Import datetime library and print current date/time

from datetime import datetime

print datetime.now()

Extracting Information

• What if you don’t want the entire date and time?
• .month() = extract month from the variable now and store it in current_year

from datetime import datetime
now = datetime.now()

current_year = now.year
current_month = now.month
current_day = now.day

Hot Date

• What if you want to print today’s date in the following format? mm/dd/yyyy
• Use string substitution/formatting again

from datetime import datetime
now = datetime.now()

print '%s-%s-%s' % (now.year, now.month, now.day)
# will print: 2014-02-19

Pretty time

• Let’s do the same for hours, minutes and seconds

from datetime import datetime
now = datetime.now()

print '%s:%s:%s' % (now.hour, now.minute, now.second)
print '%s/%s/%s %s:%s:%s' % (now.month, now.day, now.year,now.hour, now.minute, now.second)

UNIT 3: CONDITIONALS AND CONTROL FLOW

• Wouldn’t it be nice if we could give our code life, the abillity to think and make their own decisions
• control flow: pick one outcome over the other, based off what else is happening in the program
• Here’s an example, where you get to make an option and the program decides what happens

def clinic():
    print "You've just entered the clinic!"
    print "Do you take the door on the left or the right?"
    answer = raw_input("Type left or right and hit 'Enter'.").lower()
    if answer == "left" or answer == "l":
        print "This is the Verbal Abuse Room, you heap of parrot droppings!"
    elif answer == "right" or answer == "r":
        print "Of course this is the Argument Room, I've told you that already!"
    else:
        print "You didn't pick left or right! Try again."
        clinic()

clinic()

Comparators: Compare Closely

• Let’s start with the most simple part of control-flows, comparators:
  • == equal to
  • != not equal to
  • < less than
  • <= less than or equal to
  • > greater than
  • >= greater than or equal to
• Comparators check if a value is equal to, less than or greater than another value

# Assign True or False as appropriate on the lines below!

# Set this to True if 17 < 328 or to False if it is not.
bool_one = True   # We did this one for you!

# Set this to True if 100 == (2 * 50) or to False otherwise.
bool_two = True

# Set this to True if 19 <= 19 or to False if it is not.
bool_three = True

# Set this to True if -22 >= -18 or to False if it is not.
bool_four = False

# Set this to True if 99 != (98 + 1) or to False otherwise.
bool_five = False

Boolean Operators: To Be and/or Not to Be

• boolean operators = compare statements and result in boolean (T/F) values:
  • and = checks if both statements are true
  • or = checks if at least one statement is true
  • not = gives the opposite of the statement

     Boolean Operators
------------------------      
True and True is True
True and False is False
False and True is False
False and False is False

True or True is True
True or False is True
False or True is True
False or False is False

Not True is False
Not False is True

And

• boolean operator and returns True when both sides of the statement are True
  • 1 < 2 and 2 < 3 is True
  • 1 < 2 and 2 > 3 is False

Or

• boolean operator or returns True when at least one side of the statement is true

  • 1 < 2 or 2 > 3 is True
  • 1 > 2 or "Gold" == "Emerald" is False

Not

• The boolean operator not returns True for false statements and Falsefor true statements.
  • not False is True
  • not 41 > 40 is False

This and That (or This, But Not That!)

• Like arithmetic, there is an order of operations for boolean operators:
  1. not is evaluated first
  2. and is evaluated second
  3. or is evaluated last
  • True or not False and False returns True
    1. not evaluated first, so we get True or True and False
    2. and evaluated second, so we get True or False
    3. or evalauted last, so we get True

Conditional Statements: If, Else and Elif

• Conditional Statement Syntax

  • if is a conditional statement excecutes some code after checking if its expression is true

    if 8 < 9:
    print "Eight is less than nine!"

  • 8 < 9 is the checked expression and print... is the specified code

• If You’re Having…

  • Let’s get more practice with the if statement.

    if some_function():
    # block line one
    # block line two
    # et cetera

  • If some_function() returns True, then indented block of code will be excecuted
  • if it returns false, then the indented block will be skipped
• Else Problems, I Feel Bad for You, Son…

  • An if/else pair says: “If this expression is true, run this indented block code; otherwise, run this code after the else statement”

    if 8 > 9:
    print "I don't printed!"
    else:
    print "I get printed!"

  • example

  answer = "'Tis but a scratch!"
  
  def black_knight():
      if answer == "'Tis but a scratch!":
          return True
      else:             
          return False       # Make sure this returns False
  
  def french_soldier():
      if answer == "Go away, or I shall taunt you a second time!":
          return True
      else:             
          return False  # Make sure this returns False
  print black_knight()
  print french_soldier()

• I Got 99 Problems, But a Switch Ain’t One
  • elif = Otherwise, if the following expression is true, do this!
  • elif is only checked if the original if statement is False

  if EXPRESSION:
      do something
  elif OTHER EXPRESSION:
      do something
  else:
      do something
  
  if 8 > 9:
      print "I don't get printed!"
  elif 8 < 9:
      print "I get printed!"
  else:
      print "I also don't get printed!"

  • example

  def greater_less_equal_5(answer):
      if answer > 5:
          return 1
      elif answer < 5:          
          return -1
      else:
          return 0
  
  print greater_less_equal_5(4)
  print greater_less_equal_5(5)
  print greater_less_equal_5(6)

Piglatin

• Let’s put together all the skills we’ve learned so far, such as string manipulation and branching
• We will create a game called Piglatin, where the first letter of a word is moved to the end and ay is added
  • example python becomes yhtonpay

Piglatin Part 1

• Break it down
  1. Ask a user to input a word
  2. Make sure the user enters a valid word
  3. Convert the word from English to Piglatin
  4. Display the translation result
• Input
  • We need to ask the user for input

  print 'Welcome to the Pig Latin Translator!'
  
  # Start coding here!
  original = raw_input("Enter a word:")

• Check your self
  • Check if user actually typed something
  • Write if statement that verifies if user has written something

  print 'Welcome to the Pig Latin Translator!'
  
  # Start coding here!
  original = raw_input("Enter a word:")
  
  if len(original) > 0:
      print original
  else:
      print "empty"

• Check your self even more
  • Let’s be thorough and not only make sure that something is typed but that is only contains letters, not numbers
  • .isalpha() = returns True is object only contains alphabet characters
  • Use and to add a second condition to our if statement

  print 'Welcome to the Pig Latin Translator!'
  
  # Start coding here!
  original = raw_input("Enter a word:")
  
  if len(original) > 0 and original.isalpha():
      print original
  else:
      print "empty"

Piglatin part 2

• Now we’re ready to start translating words

• Rule: You move the first letter of the word to the end and then append the suffix ‘ay’. Example: python -> ythonpay

• Word up
  • Create variable (pyg) to hold translation suffix
  • Inside if statement:
    • Create new variable word to hold lower() case version of original
    • Create new variable first to hold first letter of the word[0]

  original = raw_input('Enter a word:')
  
  if len(original) > 0 and original.isalpha():
      pyg = 'ay'
      word = original.lower()
      first = word[0]
      print original
      print first
  else:
      print 'empty'

• Move it on back
  • Add the first letter and string stored in pyg to the end of the original string
  • Create new var new_word and store the concentenatition of word, first and pyg

  
  original = raw_input('Enter a word:')
  
  if len(original) > 0 and original.isalpha():
      pyg = 'ay'
      word = original.lower()
      first = word[0]
      new_word = word + first + pyg
      print new_word
  else:
      print 'empty'

• Final Slice
  • Well done! However, we still have the first word

  • To remove a slice of the word there are two methods

    my_string = Pikachu!
    my_string[1:len(my_string)] # "ikachu", method 1
    my_string[1:] # "ikachu", method 2. The better method!

# Final Program

original = raw_input('Enter a word:')

if len(original) > 0 and original.isalpha(): # checks if word is typed
    pyg = 'ay'
    word = original.lower()
    first = word[0]
    new_word = word + first + pyg # concetanates word, first letter and ay
    new_word = new_word[1:] # slices off first letter, keeps rest
    print new_word
else:
    print 'empty'

Unit 4: Functions

What good are functions?

• Ever wanted to re-use a bit of code but only changing a few things? Instead of re-writing the whole piece of code it’s easier to define a function which can be used repeatedly

Function Syntax

2. Function Syntax

• Functions are defined with three components
  1. The Header = includes the def keyword, the name of the function and any parameters
     def hello_world(): // There are no parameters
  2. Optional comment = explains what the function does
     """Prints 'Hello World!' to the console."""
  3. The body = describes the procedures the function carries out. Body is indented just like for conditional statements
     print "Hello World!"
  • Here’s the full function pieced together

  def hello_world():
      """Prints 'Hello World!' to the console."""
      print "Hello World!"

3. Call and Response

• After defining function it must be called to be excecuted
  • spam() in the last example told the program to look for the function spam and excecute the code inside it

def square(n):
    """Returns the square of a number."""
    squared = n**2
    print "%d squared is %d." % (n, squared)
    return squared
    
# Call the square function on line 9! Make sure to
# include the number 10 between the parentheses.
square(10) ## function is called

4. Parameters and Arguments

• Let’s re-examine the first line that defined square
  • def square(n):
• n = a parameter of square
  • A parameter acts as a variable name for a given argument
• 10 = given argument
  • in the previous example we called square with an argument of 10
  • in this instance the function was called, n holds the value 10
• A function can require as many parameters as you like, but when you call a function you should generally give a matching number of arguments

• example: Function with two parameters

  def power(base, exponent):  # Add your parameters here!
      result = base**exponent
      print "%d to the power of %d is %d." % (base, exponent, result)
  
  power(37,4)  # Add your arguments here!

5. Functions Calling Functions

• So far functions have been used to carry out arithmetic and print statements, but they can be much more powerfull and full of wizardy
• For example, a function can ,dun, dun duuun, call another function

``` def fun_one(n): return n * 5

def fun_two(m): return fun_one(m) + 7 ```

• example: Let’s create two functions. one_good_turn, which will add one 1 to the number it taske as a argument, and deserves_another which adds 2.
  • Make it that deserves_another always adds 2 to the output of one_good_turn.

  def one_good_turn(n):
      return n + 1
  
  def deserves_another(m):
      return one_good_turn(m) + 2
  
  
  print one_good_turn(10) ## output is 11
  print deserves_another(10) ## output is 13

6. Practice Makes Perfect: Function Structure!

• As a reminder, here is how functions are structured

def shout(phrase):
    if phrase == phrase.upper():
        return "YOU'RE SHOUTING!"
    else:
        return "Can you speak up?"

shout("I'M INTERESTED IN SHOUTING")

• Don’t forget the colon at the end of your function definition!

• example: Let’s create another function using conditional statements for good practice.

  def cube(number):
      """Cubes number (i.e. times itself and times itself again)"""
      cubed = number*number*number
      return cubed
  
  def by_three(number):
      """if number is divisible by three, then call "cube(number)" and return its result. Otherwise, "by_three" should return False"""
      if number % 3 == 0:
          return cube(number)
      else:
          return False
  
  print cube(9)
  print by_three(9)

Importing Modules

7. I Know Kung Fu

• Remember import this from our our date excercise? That was an example of importing a module
• module = a file that contains definitions-including variables and functions- that you can use once it is imported
• Before we go any further with fancy modules, let’s take a break to square a number

print sqrt(25)
## Nameerror: name `sqrt` is not defined

8. Generic imports

• Uh oh, Python said: “NameError: name ‘sqrt’ is not defined.” Python doesn’t know what square roots are—yet

• There is a Python module named math which contains useful functions and variables, sqrt() is one of them.

• Generic Import = To access math all you need is the import keyword. When you simply import a module this way it is called a generic import

• Example: There are two steps to using a imported function
  1. import math = import the module

  2. math.sqrt() = Insert math. before sqrt(). This tells python to not only import math, but to get the sqrt() function from within math

     # Ask Python to print sqrt(25) on line 3.
     import math
     print math.sqrt(25)

9. Function Import

• Function Import = pull in just a single fuction from a module
• importing only certain variable or functions is done using the from keyword:

from module import function

• Example:

• It can be frustrating having to type math.sqrt() every time. Pull the sqrt function from the math module
  • import only the sqrt function from math. note: you don’t need the () after sqrt in the from math import sqrt bit.

from math import sqrt
print sqrt(25)

10. Universal Imports

• universal import = Import all the variables and functions from a module:

from module import *

• example: Let’s not cherry pick a few functions and variables, bring ’em all in!

from math import *

11. Here Be Dragons: The danger of universal imports

• Universal imports might look great on the surface, but they’re not a good idea for one very important reason:

• They fill your program with a ton of variable and function names without the safety of those names still being associated with the module(s) they came from

• Safe method = import math: Generic Imports are safe
  • If you have your own function named sqrt and you import from math, your function is safe: there is sqrt and math.sqrt
• Dangerous method = from math import *: Universal imports are unsafe!
  • If you do from math import * you have a problem: two functions with the same name

• Even if your definitions don’t conflict, If you import from several modules at once you won’t be able to figure out which function or variable came from where, it’s like throwing wasabi peanuts and easter eggs into the same bowl

• Summary to being safe for kids
  • Avoid dragons (universal imports)
  • Stick to either:
    • Generic Import = import module and type module.name
    • Function Import = import specific functions and variables as needed
• Let’s look at everything available in the math module

• You’ll see useful things likesqrt, pi, factorial and trig functions

import math            # Imports the math module
everything = dir(math) # Sets everything to a list of things from math
print everything       # Prints 'em all!

Built in Functions

12. On Beyond Strings

• Now that you understand what functions are and how to import them, let’s look at some functions that are built into Python (no modules required!)
• We’ve already seen some, such as lower(), str() and len().
• These are great for strings but what about something more analytical?
• Built in analytic functions
  • Here are some functions for working with numbers rather than strings

  def biggest_number(*args):
      print max(args)
      return max(args)
  
  def smallest_number(*args):
      print min(args)
      return min(args)
  
  def distance_from_zero(arg):
      print abs(arg)
      return abs(arg)
  
  
  biggest_number(-10, -5, 5, 10) # prints 10
  smallest_number(-10, -5, 5, 10) # prints -10
  distance_from_zero(-10) # prints 10

• max() = takes any number of arguments and returns the largest one
  • *note: “Largest” can have a weird definition here, so it’s best to use max() on numbers (integers and floats), and not on other objects like strings
• min() = returns the smallest of a given series of arguments
• abs() = returns the absolute value of the number it takes as an argument
  • i.e. the number’s distance from 0 on a number line
  • 3 and -3 have the same absolute number
  • abs() function always returns a positive number, unlike max() and min()

• type() = returns the type of data it receives as an argument

  print type(42)
  print type(4.2)
  print type('spam')
  
  # Python Output
  <type 'int'>
  <type 'float'>
  <type 'str'>

Review

Review: Functions

• Let’s review functions! Here’s the general structure

def speak(message):
    return message

if happy():
    speak("I'm happy!")
elif sad():
    speak("I'm sad.")
else:
    speak("I don't know what I'm feeling.")

Review: Built in Functions

• Last but not least, let’s review Pyhton’s built-in functions
  • Steps to building a function
  1. Define: First, def a function called distance_from_zero, with one argument (choose any argument name you like)
  2. Body: If the type of the argument is either int or float, the function should return the absolute value of the function input.
  3. Otherwise, the function should return “Nope”

def distance_from_zero(thing):
    if type(thing) == int or type(thing) == float:
        return abs(thing)
    else:
        return "Nope"

Unit 4: Taking A Vacation

A review of functon creation

1. Before we Begin

• lets quickly Review functions

def bigger(first, second):
    print max(first, second)
    return True

• In the example above:
  1. We define a function called bigger that has two arguments called first and second
  2. Then we print out the larger of the two-arguments using the built-in function max()
  3. Finally, the bigger function returns True

Planes, Hotels and automobiles

2. Taking a Vacation

• Below is a refresher in how functions and arguments are defined

def wages(hours):
    # If I make $8.35/hour...
    return 8.35 * hours

3. Getting There

• Functions with Conditional Statements: Let’s give your program some brains so it can choose what code to excecute depending on the outcome of a first choice
  • Remember, functions are useful as we can change just one part without re-writing the whole code (arguments)
  • They can be even more useful when we let the program decide what happens when we give different arguments
• Below is a referesher in how functions and conditional statements are structured

def fruit_color(fruit):
    if fruit == "apple":
        return "red"
    elif fruit == "banana":
        return "yellow"
    elif fruit == "pear":
        return "green"

• Example: Let’s make a interactive programme that calculates how much your flight will cost.
  • Input: It will take a string named city as an argument
  • output: Depending on the location it will return a different price

     def plane_ride_cost(city):
  if len(city) > 0 and type(city) == str:
      if city == "Charlotte": 
          return 183
      elif city == "Tampa":
          return 220
      elif city == "Pittsburgh":
          return 222
      elif city == "Los Angeles":
          return 475
      else: 
          print "Type a accepted city"
  else:
      print "Type a accepted city"

  4. Transportation: Calculating new outputs

• Functions with Conditional Statements and Calculating New Variables
• So far our code taken an input and returned a pre-defined output
• What if the code calculates a brand new output, one that we haven’t written into the code as stone?
• To do this, the code changes the input variable, and returns a new value
• Below is an example of a function that calculates a new value
  • We first give the player 10 tickets for every point the player scored. Then, we check the value of score multiple times
  1. First we check if score is greater than or equal to 10. If it is, we give the player 50 bonus tickets
  2. if score is greater than or equal to 7, we give the player 20 bonus tickets
  3. At the end we return the total number of tickets earned by the player

def finish_game(score):
    tickets = 10 * score
    if score >= 10:
        tickets += 50
    elif score >= 7:
        tickets += 20
    return tickets

• example: Let’s calculate the cost of car rental.
  1. define a function called rental_car_cost with days as the argument
  2. Calculate the cost of renting the car:
     • Every day you rent the car it costs $40
     • If you rent the car for 7 or more days, you get $50 off your total
     • Alternatively if you rent the car for 3 or more days, you get $20 off your total
     • you cannot get both discounts
  3. Return that cost

  def rental_car_cost(days):
  cost = days * 40
  if days >= 7:
      cost = cost - 50
  elif days >= 3:
      cost = cost - 20
  return cost

5. Pull it together: Functions within Functions

• Now that we have our 3 main costs, let’s put them together to figure out the total cost of our trip
• Below is an example of the structure of a function that calls a function:
  1. We define two simple functions, double(n) and triple(p) that return 2 times or 3 times their input. Notice that they have n and p as their arguments.
  2. We define a third function, add(a, b) that returns the sum of the previous two functions when called with a and b, respectively.

def double(n):
    return 2 * n
def triple(p):
    return 3 * p

def add(a, b):
    return double(a) + triple(b)

• example: Below your existing code, define a function called trip_cost that takes two arguments, city and days.
  • Like the example above, have your function return the sum of calling the rental_car_cost(days), hotel_cost(days), and plane_ride_cost(city) functions.
  • note: it is completely valid to call the hotel_cost(nights) function with the variable days. Just like in the above example where we call double(n) with the variable a, we can pass the value of days to the new function in the argument nights.

  def hotel_cost(nights):
  # cost is 140$ per night
  return 140 * nights
  
  def plane_ride_cost(city):
      if len(city) > 0 and type(city) == str:
          if city == "Charlotte": 
              return 183
          elif city == "Tampa":
              return 220
          elif city == "Pittsburgh":
              return 222
          elif city == "Los Angeles":
              return 475
          else: 
              print "Type a accepted city"
      else:
          print "Type a accepted city"
  
  def rental_car_cost(days):
      cost = days * 40
      if days >= 7:
          cost = cost - 50
      elif days >= 3:
          cost = cost - 20
      return cost
  
  def trip_cost(city, days):
      return rental_car_cost(days) + hotel_cost(days) + plane_ride_cost(city)

6. Hey, you never know! What costs occur in Vegas, stay in Vegas

• Adding values to the output of functions

• You can’t expect to only spend money on the plane ride, hotel, and rental car when going on a vacation. There also needs to be room for additional costs like fancy food or souvenirs.
  1. Modify your trip_cost function definition. Add a third argument, spending_money.
  2. Modify what the trip_cost function does. Add the variable spending_money to the sum that it returns.

  def trip_cost(city, days, spending_money):
  return rental_car_cost(days) + hotel_cost(days) + plane_ride_cost(city) + spending_money

Unit 5: Lists and dictionaries

• Lists and dictionaries are powerful tools which you can use to store, organise and manipulate all kinds of information

Lists

1. Introduction to lists

• Lists are a datatype that you can use to store a collection of different pieces of information as a sequence under a single variable name
• For example, under the single variable name water type you can have a list of different Pokemon
• Other data types you’ve already learnt about are booleans, strings and numbers
• structure: You can assign items to a list with an expression of the form:

list_name = [item_0, item_1]

* ***note***: lists can also be empty: `empty_list = []`

• Lists are very similar to strings but there a few key differences

• example: Let’s make a zoo!

  ``` zoo_animals = [“pangolin”, “cassowary”, “sloth”, “Meowth” ];

  if len(zoo_animals) > 3: print “The first animal at the zoo is the” + zoo_animals[0] print “The second animal at the zoo is the” + zoo_animals[1] print “The third animal at the zoo is the” + zoo_animals[2] print “The fourth animal at the zoo is the” + zoo_animals[3] ``` #### 2. Access By Index

• you access a individual item on a list by using its index
• an index is like an address of that identifies an item’s place in the list
• the index appears directly after the list name, in brackets, like this list_name[index]
• note: list indices begin with zero not one! Computer scientists love counting from zero and failing at the task of normal day-to-day social interactions, the inept fools

• example:

numbers = [5, 6, 7, 8]

print "Adding the numbers at indices 0 and 2..."
print numbers[0] + numbers[2]

3. New Neighbours

• A list index behaves likes any other variable!
• That means it can be used to access aswell as assign new values
• structure:

zoo_animals = ["pangolin", "cassowary", "sloth", "meowth"]
# Last night our zoo's sloth brutally attacked 
# poor meowth and ate it whole.

## Gets the value "sloth"
zoo_animals[3]

# The ferocious sloth has been replaced by a friendly Hypno.
## Changes "sloth" to "hypno"
zoo_animals[2] = "Hypno"

List Capabillities and Functions

4. Late Arrivals and List Length

• list.apend(new_item) = add item to list
• A list doesn’t have to be a fixed length. You can add items to the end of a list anytime you like!
• structure: In the below example…
  1. We first create a list called letters
  2. Then, we add the string d to the end of the letters list

letters = ['a', 'b', 'c']
letters.append('d')
print len(letters)
print letters

5. List slicing

• slice = letters[1:3] = access a slice of the list
• Sometimes you only want to access a portion of the list
• structure:
  1. we first create a list called letters
  2. Then, we take a subsection and store it in the list slice. We start the index just before the colon and continue up to but not including the index after the colon
  3. Finally, we print out ['a', 'b', 'c', 'd', 'e'], just to show that we did not modify the original letters list

letters = ['a', 'b', 'c', 'd', 'e']
slice = letters[1:3]
print slice
print letters

6. Slicing lists and Strings

• You can slice strings exactly like lists! In fact, you can think of strings as a list of characters: each character is a sequential item on the list, starting from 0
• structure:
  • *note: remember, you don’t need the first index if your starting from the beginning of the string and you don’t need the second index if your going all the way to the end

animals = "catdogfrog"
cat  = animals[:3]   # The first three characters of animals
dog  = animals[3:6]            # The fourth through sixth characters
frog = animals[6:]              # From the seventh character to the end

7. Maintaining Order: Search and Insert!

• my_list.insert(1, "mushroom") = insert mushroom into index 1

• my_list.index("grape") = search list for the item "grape"

• Sometimes you want to search for an item in a list
  1. First we create a list called animals with three strings
  2. Then, we print the first index that contains the string "bat" which will print 1

  animals = ["ant", "bat", "cat"]
  print animals.index("bat")

• We can also insert items into a list
  1. We insert dog at index 1, which moves everything down
  2. We print out ["ant", "dog", "bat", "cat"]

  animals.insert(1, "dog")
  print animals

• example: use the .index(item) function to find the index of duck. Then use the .insert(item) function to insert cobra at that index

animals = ["aardvark", "badger", "duck", "emu", "fennec fox"]
duck_index = animals.index("duck")  # Use index() to find "duck"

animals.insert(duck_index, "cobra") 

print animals # Observe what prints after the insert operation

8. For One and All: For-Loops

• If you want to do something with every item in a list you will be happy to know of for loops.
• for every item in this list, do this!
• structure:

for variable in list_name:
    # Do stuff!

1. A variable name follows the `for` keyword; it will be assigned the value of each list item in turn
2. Then, `in list_name` designates `list_name` as the list the loop will work on. The line ends with a colon (`:`) and the indented piece of code that follows will be run once per item in the list

• example: Write a statement in the indented part of the for-loop that prints a number equal to 2 * number for every list item
  • Each list item is assigned to the user-defined variable number in turn
  • The for loop will automatically execute your code as many times as there are items in my_list!

  ``` my_list = [1,9,3,8,5,7]

  for number in my_list: # Your code here print 2 * number ```

9. More with “for”: Sorting shit out

• my_list.sort() = modifies list in order, A-Z or smallest to largest.

• if your list is a jumbled mess, you may need to sort() it

  1. First we create a list of animals, not in alphabetical order
  2. Then we sort the list alphabetically. note: sort() does not return a new list but modifies the original
  3. Then, for each animal in animals we print them out as "ant", "bat", "cat" on their own line each

animals = ["cat", "ant", "bat"]
animals.sort()

for animal in animals:
    print animal

• example:
  • Write a for-loop that repeats over start_list and .append()s each number squared (x**2) to square_list
  • Then sort square_list

  start_list = [5, 3, 1, 2, 4]
  square_list = [] # Create a empty list to hold squared numbers
  
  # Use a for-loop to square all the items in start_list
  
  for number in start_list:
      square_list.append(number**2)
  
  square_list.sort() # Sort the square_list
  
  print square_list 

Running scheduled scripts

• 1. create script. Can be ps1 (powershell) format or python
• 2. create scheduled task
  • open CMD and paste schtasks /Create /SC HOURLY /TN PythonTask /TR "PATH_TO_PYTHON_EXE PATH_TO_PYTHON_SCRIPT"
  • That will create an hourly task called ‘PythonTask’. You can replace HOURLY with DAILY, WEEKLY etc. PATH_TO_PYTHON_EXE will be something like: C:25.exe.
  • schtasks /Create /SC HOURLY /TN PythonTask /TR " C:\Python27\ArcGIS10.2\python.exe C:\Users\Prem\Documents\WindowsPowerShell\backup.py"