Day 6: Sequences, Comprehensions, Objects

2.4 Sequences

zip() - pairs elements from multiple iterables into tuples. Note: stops once the shortest input sequence is exhausted. Some main uses:

• loop over multiple lists using for name, age in zip(names, ages)
• dictionary creation

The dictionary creation is a useful trick when processing data from different formats to turn them into dictionaries. The general form is:

headers = ["name", "age", "city"]
row = ["Alice", 25, "New York"]
record = dict(zip(headers, row))
print(record)  # {'name': 'Alice', 'age': 25, 'city': 'New York'}

This is useful for a number of reasons:

• Allows us to work with dictionaries with offer fast key-based lookup instead of index.
• It avoids manual dictionary creation. Which allows us to work with data with different column structures.
• Can be used with CSVs, databases, APIs

2.5 collections module

from the author, “collections module is one of the most useful library modules in all of Python”. useful when there is a need to tabulate values. We briefly touched on the following objects for data handling: Counter , defaultdict and deque

Counter - useful for counting occurrences of elements in an iterable. Some examples:

• Word frequency in a text Counter(text.split())
• most common elements counter.most_common(3) lists the top 3, leaving blank lists all by occurence
• counting characters Counter("mississippi")

defaultdict provides default values for missing keys preventing KeyError

• You can provide a default value for missing keys defaultdict(lambda: "Not Found")
• Combine non-unique keys

deque - short for double-ended queue optimized for fast appends and pops from both ends, making it more efficient than a list for queue-like operations.

• Queue (first in, first out) queue.popleft()
• Stacks (last in, first out) stack.pop()
• Fixed-size buffers to automatically discards older elements when full. deque(maxlen=3)
• Effecient way to reverse a sequence e.g. deque.reverse()

2.6 List, Set and Dictionary Comprehensions

come from set-builder notation in math.

a = [ x * x for x in s if x > 0 ] # Python

is equivalent to

Some comon usecases:

• collect values of a specific dictionary fields:

stocknames = [s['name'] for s in stocks]

• perform database-like queries on sequences.

a = [s for s in stocks if s['price'] > 100 and s['shares'] > 50 ]

• combine a list comprehension with a sequence reduction:

cost = sum([s['shares']*s['price'] for s in stocks])

2.7 Objects

Finally clicked what it means that everything in Python is an object. The author goes through different examples that were really helpful. To revisit often in future.

Onto Program Organization tomorrow. Feeling great about my progress so far and exited learn more!

Day 5

I veered off my usual path and spent some time with a developer friend, setting up a more advanced project that’s beyond my depth.

It’s a project he’s been working on, and he was kind enough to share it with me. The process was valuable because it involved many components, and we spent the afternoon ensuring they all worked well together.

What made it even more enjoyable was diving into the Python code and trying to understand what was happening. It’ll likely take me a while to get a clear picture of everything, but I’m lucky to have direct access to the maintainer to ask questions.

The project is private for now, but I’m looking forward to more weekend afternoons of hacking when summer rolls around.

Day 4: Gaining Momentum

Today was fun. Worked through some challenging exercises. Had a bug that took me a minute to figure out: forgot to add a return statement on a function. Macrodata Refinement is hard :)

Some things covered:

File management - prefereed way to open different file types using with

Functions

• how to call function interactively e.g. python3 -i pcost.py
• sys.argv is a list that contains passed arguments on the command line (if any).

Datatypes and Data structures

• list(d) - returns all the keys.
• d.keys() returns a special dict_keys object which is an overlay on the original dictionary that always gives you the current keys—even if the dictionary changes.
• with a list of tuple pairs called items, you can create a dictionary dict(items)

Containers

• Lists. use when the order of the data matters and mostly containing the same data type.
• Dictionaries. useful if you want fast random lookups (by key name). Before Python 3.7, dictionaries did not preserve insertion order. d.get(key, default) for look up where a key might not exist.
• Sets. Unordered collection of unique items. useful for duplicate elimination.

Tomorrow: work through sections 2.3 to 2.6

Day 3

Worked through section 1.5 of PPP. Love the conciseness and the exercises at the end of each section.

brief notes on some things new to me

• Variables are case-sensitive in python. name != Name
• Bitwise operations: worked through some examples with Claude; i get the general idea but might have to revisit again.
• floating point numbers are inexact when representing decimals; not language specific issue, but the underlying floating point hardware on the CPU.

>>> a = 2.1 + 4.2
>>> a == 6.3
False
>>> a
6.300000000000001

• common string methods:

s.endswith(suffix)     # Check if string ends with suffix
s.find(t)              # First occurrence of t in s
s.index(t)             # First occurrence of t in s
s.isalpha()            # Check if characters are alphabetic
s.isdigit()            # Check if characters are numeric
s.islower()            # Check if characters are lower-case
s.isupper()            # Check if characters are upper-case
s.join(slist)          # Join a list of strings using s as delimiter
s.lower()              # Convert to lower case
s.replace(old,new)     # Replace text
s.rfind(t)             # Search for t from end of string
s.rindex(t)            # Search for t from end of string
s.split([delim])       # Split string into list of substrings
s.startswith(prefix)   # Check if string starts with prefix
s.strip()              # Strip leading/trailing space
s.upper()              # Convert to upper case

• dir() produces a list of all operations that can appear after the (.). Use the help() command to get more information about a specific operation:

>>> help(s.upper)
Help on built-in function upper:

upper(...)
    S.upper() -> string

    Return a copy of the string S converted to uppercase.
>>>

Day 2

Some brief unorganized notes on things I covered today:

Control flow and iterables.

enumerate(iterable) - yields pairs containing index and the value at index from iterables e.g. (0, seq[0]), ...). Neater way of iterating through collections like lists.

Functions

*args and **kwargs finally clicked while working through some trivially simple examples.

fn(*args) - can take any number of positional arguments, returns a tuple.

def varargs(*args):
    return(args)

varargs('one', (3,), [4,5,6,7], 8732.32)

# returns
('one', (3,), [4, 5, 6, 7], 8732.32)

fn(**kwargs) - takes any number of keyword arguments, returns dictionary.

def kwargs(**kwargs):
    return(kwargs)

kwargs(first="Liverpool", second="Nottingham Forest", third="Arsenal")

# returns
{'first': 'Liverpool', 'second': 'Nottingham Forest', 'third': 'Arsenal'}

within a function, global x invokes a variable x that’s in the global scope. while in an inner loop nonlocal x, y accesses those variables outside its local scope.

also new to me, the idea of functions that return a function. Can’t picture use cases at the moment.

def create_avg():
	total = 0
	count = 0
	def avg(n):
		nonlocal total, count
		total += n
		count += 1
		return total/count
	return avg

avg = create_avg()

avg(3) # => 3.0
avg(5) # (3+5)/2 => 4.0
avg(7) # (8+7)/3 => 5.0

other things covered today: lambda functions, comprehensions (list, set, dict), and modules. tip: dir(math) shows functions and attributes in a module.

Touched a bit on Classes. Corey Schafer’s, Python OOP Tutorials - Working with Classes, was helpful in building the intuition. Saved for future reference.

Tomorrow: Work through chapter 1 of Practical Python Programming.

Day 1: Slow Start

Worked through the following sections of Learn X in Y Minutes: Python in the REPL:

• Primitive data types and operators
• Variables and collections

Progress was slower than I wanted, but trying different examples as questions came to mind was helpful.

Rediscovered the bpython REPL. Learned that RC had a hand in bringing this project to life.

Tomorrow, I’ll work through the following sections:

• Control flow and iterables
• Functions
• Modules