Python Reference

Variables

A name for a value. Python needs no keyword at all.

score = 10
score = 25          # reassigned

NAME = "Amara"      # capitals mean do not change this

• Python has no const. All caps is a convention, not enforcement.
• JavaScript writes let or const in front.

Comments and indentation

A hash starts a comment. Indentation is not style here, it is the syntax.

# a note for a human

if score > 10:
    print("inside the if")
print("outside again")

• Getting the indentation wrong changes what the program does, not just how it looks.

Strings

Text. An f-string drops values straight in.

name = "Amara"
greeting = f"Hello, {name}"

len(name)            # 5
name.upper()         # "AMARA"
name[0]              # "A"
"  hi  ".strip()     # "hi"
"a,b,c".split(",")   # ["a", "b", "c"]

• JavaScript uses backtick templates and name.length rather than len().

Converting between types

Input arrives as text. Convert before doing arithmetic.

int("42")       # 42
float("3.5")    # 3.5
str(42)         # "42"

"7" + "3"       # "73"  joined
int("7") + 3    # 10    added

"42".isdigit()  # check before converting

• isdigit() is how you check text is safe to convert without an exception.

Dictionaries

Named fields. JavaScript calls the same idea an object.

member = {"name": "Ama", "hours": 40}

member["name"]            # "Ama"
member.get("city", "?")   # a safe default
member["city"] = "Atlanta"
member.keys()

• .get() returns a default instead of raising a KeyError, which is often what you want.

Sets and comprehensions

A set holds unique values. A comprehension builds a list in one line.

unique = set(names)          # duplicates removed

evens = [n for n in nums if n % 2 == 0]
doubled = [n * 2 for n in nums]

sorted(members, key=lambda m: m["hours"], reverse=True)

• Membership in a set is far faster than scanning a list, which is how O(n squared) becomes O(n).

Loops

for walks a collection directly. while repeats until a condition stops being true.

for n in numbers:
    total += n

for i in range(5):     # 0 to 4
    print(i)

while balance < goal:
    balance += 75

• range stops before the number you give it.
• A while loop needs something inside it to change, or it never ends.

Errors

Wrap risky work, handle the failure, and let finally clean up either way.

try:
    n = int(text)
except ValueError:
    n = 0
finally:
    print("Always runs")

raise ValueError("empty list")

• Catch the specific error you expect rather than everything.

Scope

Assigning inside a function creates a local variable. The outer one is untouched.

count = 10

def change():
    count = 99      # a different variable

change()
# count is still 10

• Arguments are local too, so reassigning one inside a function does not affect the caller.

Files

with open guarantees the file is closed, even if something fails partway.

with open("notes.txt") as f:
    contents = f.read()

with open("out.txt", "w") as f:
    f.write("done\n")

• A browser cannot touch your filesystem, so this one is for Python on your own machine.

Complexity

How the work grows as the input grows. Sequence adds, nesting multiplies.

O(1)       indexing
O(log n)   binary search
O(n)       one loop
O(n log n) a good sort
O(n^2)     nested loops

• Swapping a nested search for a set lookup turns O(n squared) into O(n).
• Make it correct first, measure, then optimise.

Edge cases worth testing every time

The six that catch the overwhelming majority of real defects.

[]           # empty
[x]          # one item
[x, x, x]    # all identical
             # answer first
             # answer last
[-3, -9]     # negatives
0            # zero