Learning Python: Action

Action dictates data and program flow. In my old Liberty BASIC programs, I feel lost in the action after years of not writing any.

Maybe one day I will learn it again, but for now, I am focused on Python.

Without action, our data from the last post will sit and collect imaginary dust. To counter this would require ways to access, change, and use our data.

Accessing Data

In Python, []s are used to access sequence data such as list and dict.

coolThings = ['Ice', 'Snow']
funCityByState = {"CA" : "Los Angeles", "VA" : "Sterling", "NC" : "New Bern"}

secondBest = coolThings[1]
bestInVA = funCityByState["VA"]

Sequence data is sliceable with [begin:end]. Either boundary can be left out to grab the rest of the list in that direction. The element at index end is not included.

coolThings = ['Ice', 'Snow', 'Rain', 'Water']

bestThings = coolThings[1:]
# Grabs all elements after and including index 1 ("Snow")

comparableThings = coolThings[:3]
# Grabs all elements before index 3 ('Water')

New elements can be added to our sequences using append() for list and [] for dict.

listNames = ['coolThings', 'bestThings']
listNames.append('comparableThings')

flights = {"2016" : 2}
flights['2017'] = 5

Modifying Data

An eye into our Python box would be useful. The print() function shows data in a console. We can now see changes in data.

age = 18
age = 19

print(age)
# -> 19

The int is supposedly immutable. What is happening here? The age variable points to a reference object that does not change. Any change to age creates a new reference object with that changed value. To see this behavior, we can check each object’s unique number using id().

age = 18
print(id(age))
# -> 1862560144

age = 19
print(id(age))
# -> 1862560160
# age points to a new object now


# Lists are mutable, unlike int
# Mutable data does not juggle objects
coolList = ["Ice", "Snow"]
print(id(coolList))
# -> 48607480

coolList.append("Rain")
print(id(coolList))
# -> 48607480
# coolList points to the same object

There is an upside to this behavior. If you pass an immutable variable to a function that messes with it, the original variable will not be changed. This preserved immutability can be tested by writing our own functions.

Functions

Python uses def to declare a function. Like most languages, arguments are comma-separated within the parantheses and return is used to return data.

def blipBleep():
  return "blip bleep!"

print(blipBleep())

To test the immutability of int, we can write a function that tries to alter one.

def addFive(input):
  input = input + 5

ourInt = 10
addFive(ourInt)

print(ourInt)
# -> 10

A common function to write is one that sorts a list of numbers. We need logic to sort numbers.

Logic

Logic directs the flow of the program based on our data. The most common directors are if and for as well as their many variations. Python’s if statements require a colon, like functions, and use == for equality.

if 5 > 3:
  print("Hey, this should print!")

if 3 == 3:
  print("This should print too.")

if 5 < 3:
  print("This one won't print. Welp.")

The for loop in Python grabs from a range of elements using in rather than counting up to (or down from) a boundary.

funWords = ['Kerfuffle', 'Alabaster']

# word holds each element in the proposed list

for word in funWords:
  print(word)

# -> 'Kerfuffle'
# -> 'Alabaster'

# You can even iterate through a string
place = "Venice"

for letter in place:
  print(letter)

# -> "V"
# -> "e"
# -> "n"
# -> "i"
# -> "c"
# -> "e"

To imitate boundary loops, the range() function proves useful. This style gives you the index of the element.

for x in range(0, 2):
  print(funWords[x])

# Note: range() function has exclusive end boundaries.
#       x never becomes 2.


# We can imitate stepping size with
# the third parameter in range()

for evenNumber in range(2, 10, 2):
  print(evenNumber)

sortNumbers()

Let’s build a function that sorts numbers. The function should take in a list of numbers and sort order. Mutable data should not be altered. To achieve this, we will copy our input into a new variable nums using the list() function.

def sortNumbers(numberList, sortOrder):
  nums = list(numberList)

To go the bubble sort way, we need to compare each number to other numbers in the list. If one number is larger or smaller than another, depending on sort order, it will be swapped with the other number.

First, we need a loop that grabs each number. The len() function returns the size of a list which is useful for our boundary loops.

def sortNumbers(numberList, sortOrder):
  nums = list(numberList)
  size = len(nums)

  for firstIndex in range(0, size):

The function needs a second loop of numbers for comparison. This one selects every number except the one we are already on.

def sortNumbers(numberList, sortOrder):
  nums = list(numberList)
  size = len(nums)

  for firstIndex in range(0, size):
    for secondIndex in range(firstIndex+1, size):

Comparison can now take place, but the function should allow sorting from largest or from smallest. sortOrder is one of our parameters. If it is 1, sort by largest. Any other value will sort by smallest. The else director splits the function’s direction.

def sortNumbers(numberList, sortOrder):
  nums = list(numberList)
  size = len(nums)

  for firstIndex in range(0, size):
    for secondIndex in range(firstIndex+1, size):
      if sortOrder == 1:
        # Sort by largest
      else:
        # Sort by smallest

To sort by largest, the element at firstIndex should be swapped with the one at secondIndex when needed. We used a variable tmp to hold the value before switching the values.

def sortNumbers(numberList, sortOrder):
  nums = list(numberList)
  size = len(nums)

  for firstIndex in range(0, size):
    for secondIndex in range(firstIndex+1, size):
      if sortOrder == 1:
        if nums[firstIndex] < nums[secondIndex]:
          # firstIndex element is smaller?
          # Push it up the list
          tmp = nums[secondIndex]
          nums[secondIndex] = nums[firstIndex]
          nums[firstIndex] = tmp
      else:
        # Sort by smallest
  return nums

The same swap can be performed for sorting by smallest with a change of inequality sign.

def sortNumbers(numberList, sortOrder):
  nums = list(numberList)
  size = len(nums)

  for firstIndex in range(0, size):
    for secondIndex in range(firstIndex+1, size):
      if sortOrder == 1:
        if nums[firstIndex] < nums[secondIndex]:
          tmp = nums[secondIndex]
          nums[secondIndex] = nums[firstIndex]
          nums[firstIndex] = tmp
      else:
        if nums[firstIndex] > nums[secondIndex]:
          tmp = nums[secondIndex]
          nums[secondIndex] = nums[firstIndex]
          nums[firstIndex] = tmp
  return nums

numbers = [99, 3, 45, 60, 20, 23, 22, 4, 8]

print(sortNumbers(numbers, 0))
# -> [3, 4, 8, 20, 22, 23, 45, 60, 99]

print(sortNumbers(numbers, 1))
# -> [99, 60, 45, 23, 22, 20, 8, 4, 3]

Not the prettiest or fastest function, but it is worthwhile practice. A moment spent Google searching reveals Python has a built-in function called sort(). Fundamentals are important, and I plan to continue strengthening them, but many functions have already been written. How do we use these?

Importing

To import, use the import keyword and the module name. The dir() function shows all functions of a module.

# Built-in Module called 'math'
import math

print(dir(math))
# -> *huge list of math functions*

You can also grab specific functions (or all using * as a wildcard) from a module using the from keyword.

# import sqrt() from math module
from math import sqrt

print(sqrt(36))
# -> 6.0

Conclusion

Basic tasks in Python such as accessing or changing data, creating functions, and using logic are now possible. I feel comfortable with the basics but digging deeper shows I cannot cover everything in one blog post. For example, I did not cover class, del, user input, finally and more.

The next post will be about basic Python language conventions. While that wraps up the three basic linguistic parts, I will practice and write more Python. There is more to discover in this intuitive and inviting language.