Python Learning Notes

$ python3 -q
>>> 2+2
4
>>> quit()

print(2+2)

$ python3 test.py
4

#!/usr/bin/env python3
print(2+2)

$ chmod +x test.py
$ ./test.py
4

$ python3 -m venv --help
usage: venv [-h] [--system-site-packages] [--symlinks | --copies] [--clear] [--upgrade] [--without-pip]
            [--prompt PROMPT] [--upgrade-deps]
            ENV_DIR [ENV_DIR ...]

Creates virtual Python environments in one or more target directories.
. . .

$ python3 -m webbrowser https://www.google.com

disaster = True
if disaster:
    print("Woe!")
else:
    print("Whee!")

x = 1  # x = 1;

a = 1; b = 2; print(a + b) # Three statements on one line

# 60 sec/min * 60 min/hr * 24 hr/day
seconds_per_day = 86400

seconds_per_day = 86400 # 60 sec/min * 60 min/hr * 24 hr/day

# Python does NOT
# have a multiline comment.
print("No comment: quotes make the # harmless.")

variable_name: type
def func(argument: type) -> type

age: int = 30
pi: float = 3.14159

def greet(name: str) -> str:
  """Greets the provided name."""
  return f"Hello, {name}!"

# assignment statements
spam = 'Spam'                   # simple assignment
spam, ham = 'yum', 'YUM'        # tuple unpacking
[spam, ham] = ['yum', 'YUM']    # list unpacking
a, b, c, d = 'spam'             # sequence unpacking (each character to a variable)
a, *b = 'spam'                  # extended sequence unpacking (a='s', b=['p', 'a', 'm'])
spam = ham = 'lunch'            # multiple assignment (both variables refer to the same object)
spams += 42                     # augmented assignment (equivalent to spams = spams + 42)

type(5.20)  # <class 'float'>
id(5.20)  # 140683748269744
x = y = z = 0  # More than one variable name can be assigned a value at the same time
sys.getrefcount(x)  # 1000000591
del y
sys.getrefcount(x)  # 1000000590
del z
sys.getrefcount(x)  # 1000000589

type(7)  # <class 'int'>
type(7) == int  # True
isinstance(7, int)  # True

# iteration
for item in ['meow', 'bark', 'moo']:
    print(item)

# range
a = ['meow', 'bark', 'moo']
for i in range(len(a)):
    print(a[i])

# enumeration
for index, item in enumerate(['meow', 'bark', 'moo']):
    print(f'Index: {index}, Item: {item}')

# comparisons
('meow', 'bark', 'moo') == ('meow', 'bark', 'moo')  # True
('meow', 'bark', 'moo') >= ('meow', 'bark')  # True
('meow', 'bark', 'moo') > ('meow', 'bark')  # True

# `+`, `*`
('cat',) + ('dog', 'cattle')  # ('cat', 'dog', 'cattle')
('bark',) * 3  # ('bark', 'bark', 'bark')

# unpacking
cat, dog, cattle = ('meow', 'bark', 'moo')

# testing with `in`
'c' in 'cat'  # True
'meow' in ['cat', 'cattle', 'dog']  # False

# indexing, and slicing a shallow copy subsequence:
s = 'hello!'  # len(S) is 6
# S[-7], S[6]  # IndexError: string index out of range

# The slice expression X[I:J:K] is equivalent to indexing with a slice object: X[slice(I, J, K)]:
#    slice(stop)
#    slice(start, stop[, step])
#
# [:] extracts the entire sequence from start to end.
# [start:] specifies from the start offset to the end.
# [:end] specifies from the beginning to the end offset minus 1.
# [start:end] indicates from the start offset to the end offset minus 1.
# [start:end:step] extracts from the start offset to the end offset minus 1, skipping characters by step.

# Indexing (S[i]) fetches components at offsets:
#   The first item is at offset 0.
#   Negative indexes mean to count backward from the end or right.
#     Technically, a negative offset is added to the length of a sequence to derive a positive offset.
#   S[0] fetches the first item.
#   S[−2] fetches the second item from the end (like S[len(S)−2]).
#
# Slicing(S[i:j]) extracts contiguous sections of sequences:
#   The upper bound is noninclusive.
#   Slice boundaries default to 0 and the sequence length, if omitted.
#   S[1:3] fetches items at offsets 1 up to but not including 3.
#   S[1:] fetches items at offset 1 through the end(the sequence length).
#   S[:3] fetches items at offset 0 up to but not including 3.
#   S[:−1] fetches items at offset 0 up to but not including the last item.
#   S[:] fetches items at offsets 0 through the end—making a top-level copy of S.
#
# Extended slicing (S[i:j:k]) accepts a step ( or stride) k, which defaults to + 1:
#   Allows for skipping items and reversing order(using a negative stride).

s[:], s[0:6], s[:6], s[:6:], s[0:6:], s[0:6:1]  # ('hello!', 'hello!', 'hello!', 'hello!', 'hello!', 'hello!')
s[::-1]  # '!olleh'
len(s), s[-1], s[len(s)-1], s[-len(s)], s[0]  # (6, '!', '!', 'h', 'h')

letter = 'o'
if letter == 'a' or letter == 'e' or letter == 'i' or letter == 'o' or letter == 'u':
    print(letter, 'is a vowel')
else:
    print(letter, 'is not a vowel')

# The `==` operator tests value equivalence.
#   Python performs an equivalence test, comparing all nested objects recursively.
#
# The `is` operator tests object identity.
#   Python tests whether the two are really the same object (i.e., live at the same address in memory).
S1 = 'spam'
S2 = 'spam'
S1 == S2, S1 is S2
(True, True)

cafe = 'café'

# len() function on string counts Unicode characters, not bytes:
len(cafe)  # 4

cafe_bytes = cafe.encode()  # b'caf\xc3\xa9'

# len() returns the number of bytes:
len(cafe_bytes)  # 5

cafe_text = cafe_bytes.decode()  # 'café'

'Snap'
"Crackle"
"'Nay!' said the naysayer. 'Neigh?' said the horse."
'The rare double quote in captivity: ".'
'''Boom!'''
"""Eek!"""

poem = '''There was a Young Lady of Norway,
    Who casually sat in a doorway;
    When the door squeezed her flat,
    She exclaimed, "What of that?"
    This courageous Young Lady of Norway.'''
print(poem)

There was a Young Lady of Norway,
    Who casually sat in a doorway;
    When the door squeezed her flat,
    She exclaimed, "What of that?"
    This courageous Young Lady of Norway.

# the line ending characters, and leading or trailing spaces are preserved as below:
'There was a Young Lady of Norway,\n    Who casually sat in a doorway;\n    When the door squeezed her flat,\n    She exclaimed, "What of that?"\n    This courageous Young Lady of Norway.'

hi = 'Na ' 'Na ' 'Na ' 'Na ' \ # literal strings (not string variables) just one after the other
    + 'Hey ' * 4 \
    + '\\' + '\t' + 'Goodbye.'
print(hi)  # Na Na Na Na Hey Hey Hey Hey \	Goodbye.

actor = 'Richard Gere'
cat = 'Chester'
weight = 28

# old style (supported in Python 2 and 3): format_string % data
'My wife\'s favorite actor is %s' % actor  # "My wife's favorite actor is Richard Gere"
'Our cat %s weighs %d pounds' % (cat, weight)  # 'Our cat Chester weighs 28 pounds'
'Our cat %(cat)s weighs %(weight)d pounds' % {'cat': cat, 'weight': weight}  # dictionary-based expressions

# new style (Python 2.6 and up): format_string.format(data)
'{0}, {1} and {2}'.format('spam', 'ham', 'eggs')  # By position
'{motto}, {pork} and {food}'.format(motto='spam', pork='ham', food='eggs')  # By keyword
'{motto}, {0} and {food}'.format('ham', motto='spam', food='eggs')  # By both
'{}, {} and {}'.format('spam', 'ham', 'eggs')  # By relative position
# 'spam, ham and eggs'

# f-strings (Python 3.6 and up): f, F
f'Our cat {cat} weighs {weight} pounds'  # 'Our cat Chester weighs 28 pounds'

import re

p = 'Les Fleurs du Mal'  # pattern
c = re.compile(p)  # compile
s = "Charles Baudelaire's 'Les Fleurs du Mal'"  # source
m = c.search(s)  # match
if m:  # m != None
    print("Mon cœur est comme une feuille sèche, emportée par le vent...")

m = re.match('Les Fleurs du Mal', s)  # find exact beginning match with match()
print(m)  # return a Match object
# None

m = re.search('Les Fleurs du Mal', s)  # find first match with search()
print(m)  # return a Match object
# <re.Match object; span=(22, 39), match='Les Fleurs du Mal'>

m = re.findall('es', s)  # find all matches with findall()
print(m)  # return a list
# ['es', 'es']

m = re.split(r'\s', s)  # split at matches with split()
print(m)  # return a list
# ['Charles', "Baudelaire's", "'Les", 'Fleurs', 'du', "Mal'"]

m = re.sub("'", '?', s)  # replace at matches with sub()
print(m)  # return a string
# Charles Baudelaire?s ?Les Fleurs du Mal?

tweet_limit = 280
tweet_string = "Blah" * 50
if diff := tweet_limit - len(tweet_string) >= 0:  # walrus operator
    print("A fitting tweet")
else:
    print("Went over by", abs(diff))

color = "mauve"
if color == "red":
    print("It's a tomato")
elif color == "green":
    print("It's a green pepper")
else:
    print("I've never heard of the color", color)

# Python runs expression Y only if X turns out to be true, and runs expression Z only if X turns out to be false.
# A = Y if X else Z  # equivalent to `((X and Y) or Z)`
A = 't' if 'spam' else 'f'  # (('spam' and 't') or 'f')
A  # 't'

# Handling switch defaults
branch = {'spam': 1.25,
          'ham': 1.99,
          'eggs': 0.99}
print(branch.get('spam', 'Bad choice'))  # 1.25
print(branch.get('bacon', 'Bad choice'))  # Bad choice
# membership test in an if statement can have the same default effect:
choice = 'bacon'
if choice in branch:
    print(branch[choice])
else:
    print('Bad choice')  # Bad choice

# handle defaults by catching and handling the exceptions they'd otherwise trigger:
try:
    print(branch[choice])
except KeyError:
    print('Bad choice')

# Handling larger actions
branch = {'spam': lambda: ...,  # A table of callable function objects
          'ham': function,
          'eggs': lambda: ...}
branch.get(choice, default)()

while True:
    value = input("Integer, please [q to quit]: ")
    if value == 'q':  # quit
        break
    number = int(value)
    if number % 2 == 0:  # an even number
        continue
    print(number, "squared is", number*number)

while x:  # Exit when x empty
    if match(x[0]):  # Value at front?
        print('Ni')
        break  # Exit, go around else
    x = x[1:]  # Slice off front and repeat
else:  # break not called
    print('Not found')  # Only here if exhausted x

word = 'thud'
for letter in word:
    if letter == 'u':
        continue
    print(letter)

word = 'thud'
for letter in word:
    if letter == 'x':
        print("Eek! An 'x'!")
        break
    print(letter)
else:  # break not called
    print("No 'x' in there.")

# counter loops: range
for num in range(0, 10, 2):
    print(num)  # 0 2 ... 8

# reverse loops: range
spam = 'spam'
for i in range(len(spam) - 1, -1, -1):
    print((i, spam[i]), end='\t')
# (3, 'm')	(2, 'a')	(1, 'p')	(0, 's')

# generating both offsets and items: enumerate
for (index, item) in enumerate('spam'):
    print(f'{index}: {item}', end='\t')  # 0: s	1: p	2: a	3: m

# parallel traversals: zip
for nums in zip(range(0, 10, 2), range(1, 10, 2)):
    print(nums)  # (0, 1) (2, 3) .. (8, 9)

# to make a tuple with one or more elements, follow each element with a comma (`,`):
'cat',  # ('cat',)
'cat', 'dog', 'cattle'  # ('cat', 'dog', 'cattle')

# to make an empty tuple, using `()`, or `tuple()`:
()  # ()
tuple()  # ()

# the comma is required to make a tuple
('cat')  # 'cat'

# the parentheses is not required, but could make the tuple more visible
('cat',)  # ('cat',)
('cat', 'dog', 'cattle')  # ('cat', 'dog', 'cattle')

# for cases in which commas might also have another use, the parentheses is needed
type('cat',)  # <class 'str'>
type(('cat',))  # <class 'tuple'>

# tuple()
tuple('cat')  # ('c', 'a', 't')

# zip()
for x in zip([1, 2, 8], [1, 4, 9], ('cat', 'dog', 'cattle', 'chicken')):
     print(x)
# (1, 1, 'cat')
# (2, 4, 'dog')
# (8, 9, 'cattle')

# generator expression
nums = tuple(range(10))  # (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
(x for x in nums if x % 2 == 0)  # <generator object <genexpr> at 0x7fcd7069b920>

# named tuples are a tuple/class/dictionary hybrid.
from collections import namedtuple  # import extension type
Rec = namedtuple('Rec', ['name', 'age', 'jobs'])  # make a generated class
bob = Rec('Bob', age=40.5, jobs=['dev', 'mgr'])  # a named-tuple record
print(bob)  # Rec(name='Bob', age=40.5, jobs=['dev', 'mgr'])

bob[0], bob[2]  # access by position
('Bob', ['dev', 'mgr'])

bob.name, bob.jobs  # access by attribute
('Bob', ['dev', 'mgr'])

# converting to a dictionary supports key-based behavior when needed:
O = bob._asdict()  # dictionary-like form
O['name'], O['jobs']  # access by key too
('Bob', ['dev', 'mgr'])
O
# OrderedDict([('name', 'Bob'), ('age', 40.5), ('jobs', ['dev', 'mgr'])])

# create with `[]` or `list()`
[]  # []
['meow', 'bark', 'moo']  # ['meow', 'bark', 'moo']
[('cat', 'meow'), 'bark', 'moo']  # [('cat', 'meow'), 'bark', 'moo']
list()  # []
list('cat')  # ['c', 'a', 't']

# append(), insert()
wow = ['meow']  # ['meow']
wow.append('moo')  # ['meow', 'moo']
wow.insert(1, 'bark')  # ['meow', 'bark', 'moo']

# index, and slice assignment
L = ['spam', 'Spam', 'SPAM!']
# index assignment
L[1] = 'eggs'  # ['spam', 'eggs', 'SPAM!']
# slice assignment: delete+insert
L[0:2] = ['eat', 'more']  # ['eat', 'more', 'SPAM!']

# del, remove(), pop(), clear()
farm = ['cat', 'dog', 'cattle', 'chicken', 'duck']

del farm[-1]
# ['cat', 'dog', 'cattle', 'chicken']

farm.remove('dog')
# ['cat', 'cattle', 'chicken']

# pop: remove and return item at index (default last).
farm.pop()  # 'chicken'
# ['cat', 'cattle']

farm.pop(-1)  # 'cattle'
# ['cat']

farm.clear()
# []

# sort() and sorted()
farm = ['cat', 'dog', 'cattle']

# a sorted copy
sorted(farm)  # ['cat', 'cattle', 'dog']
print(farm)  # ['cat', 'dog', 'cattle']

# sorting in-place
farm.sort()
print(farm)  # ['cat', 'cattle', 'dog']

# shallow copy: any changes made to the elements within the original list will also be reflected in the copy.
a = [['cat', 'meow'], ['dog', 'bark']]
c = a[:]
b = a.copy()  # equivalent to list slicing ([:] )but might be slightly less efficient.
d = list(c)

# deep copy: changes to elements within the original list won't affect the copy (and vice versa) because they point to different objects in memory.
import copy
e = copy.deepcopy(a)

a[0][1] = 'moo'
a  # [['cat', 'moo'], ['dog', 'bark']]
b  # [['cat', 'moo'], ['dog', 'bark']]
c  # [['cat', 'moo'], ['dog', 'bark']]
d  # [['cat', 'moo'], ['dog', 'bark']]

e  # [['cat', 'meow'], ['dog', 'bark']]

# list comprehensions: [expression for item in iterable]
even_numbers = [2 * num for num in range(5)]
# [0, 2, 4, 6, 8]
# list comprehensions: [expression for item in iterable if condition]
odd_numbers = [num for num in range(10) if num % 2 == 1]
# [1, 3, 5, 7, 9]

# from collections import deque
q = deque([], maxlen=5)
q.maxlen  # 5
q.append(0)  # deque([0], maxlen=5)
q.extend([1,2])  # deque([0, 1, 2], maxlen=5)
q.extendleft([3,4])  # deque([4, 3, 0, 1, 2], maxlen=5)
q.appendleft(5)  # deque([5, 4, 3, 0, 1], maxlen=5)
q.pop()  # 1
q.popleft()  # 5

L = [1, 2, 3]  # iterable
I = iter(L)  # iterator
next(I)
# 1
next(I)
# 2
next(I)
# 3
next(I)
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# StopIteration

# Creating and manipulating files and directories:
Path.mkdir()    # Create a new directory.
Path.unlink()   # Remove a file.
Path.rmdir()    # Remove an empty directory.
Path.rename()   # Rename a file or directory.
Path.copy()     # Copy a file or directory.
Path.replace()  # Move a file or directory.

# Getting information about files and directories:
Path.exists()   # Check if a path exists.
Path.is_file()  # Check if a path is a file.
Path.is_dir()   # Check if a path is a directory.
Path.stat()     # Get information about a file or directory (e.g., size, modification time).
Path.iterdir()  # Iterate over the contents of a directory.

# Working with file paths:
Path.joinpath() # Join multiple path components into a single path.
Path.parent     # Get the parent directory of a path.
Path.name       # Get the name of a file or directory.
Path.stem       # Get the name of a file without the extension.
Path.suffix     # Get the file extension.
Path.resolve()  # Convert a relative path to an absolute path.

# Using context managers:
Path.open()     # Open a file for reading or writing.

X = 88  # Global X

def func():
    global X
    X = 99  # Global X: outside def

func()
print(X)  # Prints 99

def tester(start):
    state = start  # Each call gets its own state

    def nested(label):
        nonlocal state  # Remembers state in enclosing scope
        print(label, state)
        state += 1  # Allowed to change it if nonlocal
    return nested

# Increments state on each call
F = tester(0)
F('spam')  # spam 0
F('ham')   # ham 1
F('eggs')  # eggs 2

class name: ...  # standard class definition
class name(): ...  # less common approach (equivalent in functionality)

# superclass links are made by listing classes in parentheses in a class statement header.
class name(superclass, ...):  # assign to name
    # class attributes are created by statements (assignments) in class statements.
    attr = value  # class data attributes, shared by all instances

    def method(self, ...):  # methods
        # instance attributes are generated by assignments to self attributes in methods.
        self.attr = value  # per-instance data

class Cat:
    color = 'red'

cat = Cat()  # create an object from a class
tom = Cat()
jerry = Cat()
print(tom.color)  # red
print(jerry.color)  # red

tom.color = 'black'  # object attributes take precedence over class attributes when accessed or modified
Cat.color = 'blue'  # affect existing and new objects

butch = Cat()
print(jerry.color)  # blue
print(tom.color)  # black
print(butch.color)  # blue

class Cat:
    def wow(self):
        print('meow!')

tom = Cat()
tom.wow()  # meow!
Cat.wow(tom)  # meow!

tom = Cat()
tom.color = 'blue'
tom.__class__.color  # red
tom.color  # blue

class Super:
    def hello(self):
        self.data1 = 'spam'

class Sub(Super):
    def hola(self):
        self.data2 = 'eggs'

x = Sub()
x.__dict__  # instance namespace dict
# {}
x.__class__  # class of instance
# <class '__main__.Sub'>
x.__class__.__name__
# 'Sub'
Sub.__bases__  # superclasses of class
# (<class '__main__.Super'>,)
Super.__bases__
# (<class 'object'>,)

x.hello()
x.__dict__
# {'data1': 'spam'}
x.hola()
x.__dict__
# {'data1': 'spam', 'data2': 'eggs'}
x.data1, x.__dict__['data1']
# ('spam', 'spam')
x.data3 = 'toast'
x.__dict__
# {'data1': 'spam', 'data2': 'eggs', 'data3': 'toast'}

x.__dict__['hello']
# KeyError: 'hello'

# initialization: __init__(), to save syllables, double underscores (__), also pronounce as dunder.
class Cat:
    # self is not a reserved word, but it’s common as the first argument to refer to the object itself.
    def __init__(self, name):  # initializer
        self.name = name

    # a method is a function in a class or object.
    def wow(self):
        print(f'{self.name:}: meow!')


cat = Cat('Tom')
cat.wow()  # Tom: meow!
Cat.wow(cat)  # Tom: meow!