#!/usr/bin/env python

# This is a file of reminders of various neat Python features

# that I always forget how to use.

# On #python as of early 2017, recommended beginning Python books include

# http://greenteapress.com/wp/think-python-2e/

# https://automatetheboringstuff.com/

# (the oft-recommended "Learn Python the Hard Way" is not well favored).

# I can't vouch for these books myself.

########################################################

# Interactive Python interpreter

########################################################

# modulename isn't quoted, and is the name you're using

# e.g. if import modulename as mn, then imp.reload(mn)

# Python 3.4 and later:

import importlib

importlib.reload(modulename)

# importlib is also useful for importing a module named by a variable, e.g.

modname = 'requests'

importlib.import_module(modname)

# Python 3.2 - 3.3:

import imp

imp.reload(modulename)

# in python2 it was built in:

reload(modulename)

#############################################################

# What's available in objects and modules? and type-checking.

#############################################################

# Show methods in an object

dir(obj)

# Does a function exist in an object?

if hasattr(obj, 'attr_name'):

if 'attr_name' in dir(obj):

# Does a function exist in a module?

hasattr(os, 'get_terminal_size'):

# You can also get with a default:

getattr(os, 'get_terminal_size', "Doesn't exist")

# Is a variable defined? You have to check locals and globals separately.

if 'myVar' in locals():

if 'myVar' in globals():

# Or, more generally,

try:

myVar

except NameError:

myVar = None

# Is something a particular type? (But of course duck-typing is better.)

if type(s) is str:

print("It's a string")

if isinstance(s, str):

print("It's a string")

# More deprecated:

if type(s) == types.StringType:

print "It's a string"

# Is something list-like, iterable?

if hasattr(l, "__getitem__"):

print "It's list-like"

else:

print "It's more scalar-like"

# Be cautious with this, though: strings are list-like.

# Is something a dict? Use isinstance rather than type()

# because isinstance will work for derived classes.

if isinstance(x, dict)

# Difference between is and ==:

# is checked whether two things are the same object (reference equality),

# == only tests for value equality.

#

# The place where this is most important is nan: (nan == nan) -> False

# but (nan is nan) -> True.

# However, in lists or tuples this breaks, [nan] == [nan] -> True

# You can also use math.isnan(x)

#

# Testing thing is None rather than thing == None is idiomatic;

# testing thing == None supposedly allows a few non-None objects

# to masquerade as None, but I haven't been able to find an example.

# Of course, don't use "is" for lists, strings or other complex types,

# or even for integers; it may work for small integers because python

# caches them, but not for larger ones.

# Update an object from a dictionary, obj.something = d['something']

for k in d:

setattr(obj, k, d[k])

# Initialize a list to multiple copies of something.

# DON'T USE l = [ [] ] * 10 -- you'll get ten copies of the same list!

# Instead,

l = [ [] for i in range(10) ]

# There is no such thing as Maximum/minimum integers any more.

# https://docs.python.org/3.1/whatsnew/3.0.html#integers

"""The sys.maxint constant was removed, since there is no longer a limit

to the value of integers. However, sys.maxsize can be used as an integer

larger than any practical list or string index. It conforms to the

implementation\u2019s \u201cnatural\u201d integer size and is typically

the same as sys.maxint in previous releases on the same platform

(assuming the same build options)."""

# Also from that page, PEP 0238:

"""An expression like 1/2 returns a float. Use 1//2 to get the

truncating behavior."""

# Maximum/minimum floats

>>> sys.float_info.max

1.7976931348623157e+308

>>> sys.float_info.min

2.2250738585072014e-308

########################################################

# Conditional import and testing imported libraries

########################################################

try:

import foo

except:

pass

import sys

if 'foo' in sys.modules:

myfoo = foo.Foo()

else:

myfoo = None

########################################################

# Import of runtime-specified modules and functions

########################################################

modulename = 'MyModule'

functionname = 'TheFunction'

themodule = __import__(modulename)

val = getattr(themodule, functionname)()

# Also, a note on importing:

# "from pytopo import user_agent" makes a copy of

# the variable and doesn't see later changes.

# If you want to see changes, you need to

# import pytopo and have it be pytopo.user_agent.

########################################################

# Shell One-liners

########################################################

# Python gives unclear errors if you try to make a one-liner that

# includes multiple lines plus a loop or conditional.

# Because the loop is a compound statement which can't be included

# on the same line with a "small statement" according to Python's grammar:

# https://docs.python.org/reference/grammar.html

# Ways of getting around this:

# Pass the program as stdin:

echo 'import time\nl = range(10)\nfor i in l: print(i)' | python

# Combining semicolons (e.g. from an import line) and a for loop

# doesn't work, syntax error.

# https://stackoverflow.com/questions/2043453/executing-multi-line-statements-in-the-one-line-command-line

# Instead, use ANSI quoting in bash, zsh or ksh along with \n:

python -c $'import time\nl = range(10)\nfor i in l: print(i)\n'

# More POSIX compliant: use command substitution:

python -c "$(printf %b 'import sys\nfor r in range(10): print("%d:" % r)')"

# You can also sometimes rewrite loops with list comprehensions or map()

# to turn them into small statements.

########################################################

# Debugging and stack traces

########################################################

# Dump into the debugger (in 3.7 and later):

breakpoint()

# Print a stack trace -- how did we get here?

traceback.print_stack()

# Print a traceback after an exception:

print(traceback.format_exc())

# Equivalent of verbose mode in a shell: print each line before executing.

python -m trace --trace /tmp/foo.py

# Debugging in python2:

print >>sys.stderr, "foo"

# and in python3:

print('foo', file=sys.stderr)

# Suppress stdout and stderr chatter:

sys.stdout = open(os.devnull, "w")

sys.stderr = open(os.devnull, "w")

# This only works for chatter that comes from Python libraries, though.

# For an example that can suppress underlying C libraries,

# see run_main_quietly() at the end of quickbrowse.py.

# Prettyprinting

from pprint import pprint

pprint(obj)

# Binary bit fields to string: all the native ways of printing binary

# in Python insist on signed integers.

def tobin(data, width=8):

data_str = bin(data & (2**width-1))[2:].zfill(width)

return data_str

# And, speaking of bit fields, Python's ~ operator is fairly useless

# because it always turns on a sign bit, no matter how large the operand,

# and there's apparently no way to mask it off.

# So instead, use ^0xff (or appropriate length) if you want a bitwise NOT:

>>> ~0xff

-256

>>> 0xff ^ 0xff

0

# Print a listing of variables along with a traceback: see

# http://code.activestate.com/recipes/52215-get-more-information-from-tracebacks/

########################################################

# Stringy stuff

########################################################

# Decode vs. Encode:

# "string of bytes".decode('utf-8') --> unicode

# u"unicode string".encode('utf-8') --> bytes

# Either of these can take

# errors='replace', 'ignore', 'backslashreplace', 'xmlcharrefreplace'

>>> u = u'piñon'

>>> u

u'pi\xf1on'

# For Python3 skip to the end of this file.

# Fix "UnicodeEncodeError: 'ascii' codec can't encode character":

.encode('utf-8', "xmlcharrefreplace")

# Split a long string over multiple lines in the source file

url1 = ( "http://www.crummy.com/software/BeautifulSoup/"

"bs3/documentation.html" )

# Note no commas in the parenthesized one:

# parentheses without a comma inside are just grouping, not a tuple.

(42) # is type int

(42,) # is a tuple with len 1

# You can also use a backslash and no parentheses:

url2 = "http://www.crummy.com/software/BeautifulSoup/" \

"bs3/documentation.html"

# s.find vs s.index: find returns -1 if not found, index raises ValueError

#

# Fuzzy string match.

# SequenceMatcher's first argument is a function that returns true for

# characters considered to be "junk". For instance, if blanks are junk,

# lambda x: x == " "

# To consider nothing as junk, pass None.

#

from difflib import SequenceMatcher

best_ratio = -1

best_match = None

for b in string_list:

r = SequenceMatcher(None, pattern, b).ratio()

if r > best_ratio:

best_match = b

best_ratio = r

# raw string literals: r'' avoids any backslash escapes.

# printf-style %x still works, e.g. r'abc %d' % 42

r = r'abc\def'

c = 'abc\\def'

r == c # True

# Replace non-breaking spaces in unicode (python3):

s = s.replace("\u00A0"," ")

################################################################

# Regular expressions/regexp:

################################################################

# Split with a regex:

sep = re.compile('[,\s]+')

sep.split('HB42,SJR1, HR67 SB3')

# Split on multiple characters at once

re.split(', |_|-|!', thestring)

# same, but find words:

re.findall(r"[\w']+", thestring)

# Match patterns even across newlines:

re.search('[0-9]+\..*[A-Z]+', teststr, flags=re.DOTALL)

# Unintuitively, re.DOTALL is the flag that controls this.

# re.MULTILINE controls whether ^ and $ match line beginnings

# and ends in the pattern, but doesn't affect whether the

# search can cross newlines.

# Transliteration:

# https://docs.python.org/3/library/stdtypes.html#str.maketrans

abc = "abc"

abc.translate(abc.maketrans("abc", "def"))

# If there is a third argument, it must be a string, whose characters

# will be mapped to None in the result.

# You can also pass it a dictionary, but the keys are int, not str.

abc.translate({ord('a'): 'A', ord('b'): None})

# But you can dispense with the ord()s if you call maketrans:

abc.translate(abc.maketrans({'a': 'A', 'b': None}))

# There doesn't seem to be any simple equivalent to perl y/A-Z/a-z/

# -- you can set up ranges with lambdas or comprehensions

# but it gets hairy quickly.

################################################################

# Python3-specific stringy stuff

################################################################

# Migrate python2 to python3 in place (omit -n to leave a .bak):

$ 2to3 -wn file_or_directory

# To make print() work in both 2 and 3:

from __future__ import print_function

# print without a newline and to a file:

print("Hello, world", end='', file=sys.stderr)

# encode/decode between bytes and str:

>>> b'string of bytes'.decode()

'string of bytes'

>>> b'string of bytes'.decode('utf-8')

'string of bytes'

>>> 'piñon'.encode('utf-8')

b'pi\xc3\xb1on'

# But if there might be an emoji involved, for some reason, plain utf-8

# isn't enough and you need this:

print(output.encode('utf-8', "surrogatepass"))

# For a while, you could just pass encoding as a second argument

# in type coercion; This has changed in more recent python3,

# so don't use it any more.

# I don't know the limits, but it's probably best not to use things like:

>>> str(b'string of bytes')

"b'string of bytes'"

>>> str(b'string of bytes', 'utf-8')

'string of bytes'

>>> str(b'pi\xc3\xb1on')

"b'pi\\xc3\\xb1on'"

>>> str(b'pi\xc3\xb1on', 'utf-8')

'piñon'

>>> bytes('piñon', 'utf-8')

b'pi\xc3\xb1on'

# Read or write bytes from a file:

fp = open(filename, 'rb') # or 'wb'

# Write bytes to a file opened in string mode with .buffer

if hasattr(sys.stdout, 'buffer')::

sys.stdout.buffer.write(b'abc')

# Also, you can specify encoding when opening a file:

open(path, "w", encoding="utf-8")

# Conditional depending on python version:

if sys.version[:1] == '2':

from urlparse import urlparse

else:

from urllib.parse import urlparse

# Call input everywhere but make that call raw_input if it's python2:

try: input = raw_input

except NameError: pass

# OR:

if hasattr(__builtins__, 'raw_input'):

input = raw_input

#############################

# ways of formatting numbers.

# https://docs.python.org/3/tutorial/inputoutput.html

# For pre-2.6, see https://stackoverflow.com/a/2962966

# String concatenation:

filename = 'file' + str(num) + '.txt'

# Conversion Specifier:

filename = 'file%s.txt' % num

#############################

# Formatted string literals or f-strings, Python 3.6+

print(f'Fly to {name}: {lat}N {lon}E')

print(f'The value of pi is approximately {math.pi:.3f}.')

# decimals and field widths

>>> f'{math.pi:.2f}'

'3.14'

>>> f'{5:>3d}'

' 5'

>>> f'{5:0>3d}' # you can fill with any character, not just 0

'005'

# Right, left and center alignment

>>> f'{123:10d}'

' 123'

>>> f'{123:<10d}'

'123 '

>>> f'{123:^10d}'

' 123 '

# str and repr in formatted string literals

>>> animals = 'eels'

>>> print(f'My hovercraft is full of {animals!s}.') # applies str() (default)

My hovercraft is full of eels.

>>> print(f'My hovercraft is full of {animals!r}.') # applies repr()

My hovercraft is full of 'eels'.

# More formatted string literals tricks:

# Escaping braces

>>> f"{{74}}"

'{74}'

# Other bases

>>> f'{255:x}'

'ff'

>>> f'{255:o}'

'377'

>>> f'{255:b}'

'11111111'

# Adding commas

>>> f'{1234567:,}'

'1,234,567'

# Python 3.8+: shorthand for debugging

# https://stribny.name/blog/2019/06/debugging-python-programs

# https://realpython.com/python38-new-features/

>>> print(f"{i=}, {word=}")

i=42, word=everything

##### end f-strings

# Justification:

>>> x = 'ab'

>>> print(repr(x).rjust(10))

'ab'

>>> print("%10s" % x)

ab

>>> print("%-10s" % x)

ab

>>> print(str(x).rjust(10))

ab

# Older, pre-3.6 Pythons can use format():

filename = 'file{0}.txt'.format(num)

# Using variable names with format()

filename = 'file%(num)s.txt' % locals() # Neat trick

# Using string.Template:

filename = string.Template('file${num}.txt').substitute(locals()))

##### Unicode code points, names etc.

# Print by name

print(u'\N{snowman}'))

import unicodedata

print(unicodedata.name('\u03b1'))

# See also unidecode.py, e.g. for how to search in names.

####### Exceptions #####################

# Frustrations at exceptions when printing,

# when Python (even Python 3) wants to convert to ascii rather than

# the system encoding:

# I need a test case for this, so save one next time it happens!

# Otherwise, ignore this section, they're just notes to help debug

# next time I hit this problem.

# New in Python 3.7:

sys.stdout.reconfigure(errors='surrogateescape')

# In 3.6, you can get a similar effect with an env variable:

PYTHONIOENCODING=utf-8:surrogateescape

# In Python2, this might also help:

sys.setdefaultencoding('utf8')

# though it's frowned upon:

# https://stackoverflow.com/questions/3828723/why-should-we-not-use-sys-setdefaultencodingutf-8-in-a-py-script/34378962#34378962

# You'd think it would use the system locale by default for printing,

# and quite a few pages claim UTF-8 is the default, but that doesn't

# seem to be true: even in Python 3 I frequently see exceptions

# indicating that for some bizarre reason python3 is trying to

# convert to ascii for printing. And in python3, sys.getdefaultencoding()

# is already utf-8 so that doesn't explain the ascii codec exceptions.

# Speaking of exception frustrations: here's how to print a traceback

# from the current exception. Curiously, you don't need to pass in the

# actual exception.

print(traceback.format_exc())

# When raising

# Avoid "During handling of the above exception, another exception occurred":

try:

some_operation()

except (SomeError, OtherError) as e:

raise MyCustomException(e, "My custom exception") from None

# Or pass information about the inner exception:

raise MyCustomException(e, "My custom exception",

traceback.format_exc()) from None

raise MyCustomException(e, "My custom exception",

traceback.extract_stack()) from None

########################################################

# Byte strings and byte arrays

########################################################

buf = bytearray(b'\x51\x02\x00\x00\x00')

buf.append(0xa2)

buf.insert(2, 0xf7)

# struct: https://docs.python.org/2/library/struct.html

# is perhaps a better way to handle byte strings like this.

########################################################

# iterator, list and dictionary helpers

########################################################

# Remove items from a list: I always forget how to do this.

mylist.remove("item") # Removes the first instance of "item"

mylist.pop(i) # Removes and returns list[i]

# There's no single call to remove ALL instances of an item,

# so you have to use a list comprehension to do that.

# () turns a list comprehension into a generator:

>>> ( i*2 for i in range(5) )

<generator object <genexpr> at 0x7f8fc17db050>

# Dictionary comprehensions:

({i : chr(65+i) for i in range(4)}

# gives {0: 'A', 1: 'B', 2: 'C', 3: 'D'}

# Delete an item from a dictionary:

del thedic[key]

# Insert an item into a list BEFORE the given index:

l = ['a', 'b', 'c', 'd', 'e']

l.insert(3, 'xxx')

# --> ['a', 'b', 'c', 'xxx', 'd', 'e']

# List comprehensions can be multiple:

[ a*b+c for a in A for b in B for c in C ]

# though itertools.product is arguably cleaner for math problems like that.

# Comprehensions can also have 'if' expressions, but the syntax

# is a little tricky and inconsistent. A conditional with no "else"

# must come at the end, after the list, but a conditional with an else

# may come before the list.

nums = [1, 2, 3, 4, 5]

odds = [n for n in nums if n%2]

isodd = ['t' if n%2 else 'f' for n in nums]

# There are dict comprehensions too though the syntax is more fiddly:

>>> { key: value for key, value in [ (1, 11), (2, 22), (3, 33) ] }

{1: 11, 2: 22, 3: 33}

>>> { key: value for key, value in zip( [1, 2, 3], [11, 22, 33] ) }

{1: 11, 2: 22, 3: 33}

# dictionary default values, several ways:

# With regular dicts

total['newvalue']] = total.get(key, 0) + 42

# With collections:

from collections import defaultdict

total = defaultdict(int)

total['newvalue'] += 42

names = defaultdict(list)

# While we're looking at collections, another useful collection is:

from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])

p = Point(11, y=22)

print(p.x, p.y)

EmployeeRecord = namedtuple('EmployeeRecord',

'name, age, title, department, paygrade')

import csv

for emp in map(EmployeeRecord._make, csv.reader(open("employees.csv", "rb"))):

print(emp.name, emp.title)

# Pairwise loops with zip():

names = ["Eiffel Tower", "Empire State", "Sears Tower"]

heights = [324, 381, 442]

for name, height in zip(names, heights):

print("%s: %s meters" % (name, height))

# Same thing with enumerate:

for i, (name, height) in enumerate(zip(names, heights)):

print("%d: %s: %s meters" % (i, name, height))

# Or make a dictionary from a zip():

tall_buildings = dict(zip(names, heights))

print max(tall_buildings.values())

#

# Read a file of name=value pairs and return a dictionary.

#

# https://mail.python.org/pipermail/baypiggies/2015-October/009556.html

def file2dict(filename):

with open(filename) as af:

return dict(line.strip().split('=',1) for line in af)

#

# Walk a directory tree

#

def walkfiles(rootdir):

for root, dirs, files in os.walk(rootdir):

for f in files:

print os.path.join(root, f)

# os.walk is handy, but it doesn't allow any type of sorting.

# So here's a rewritten os.walk that sorts alphabetically.

def pathwalk(top, topdown=True, onerror=None, followlinks=False, sortfn=None):

# We may not have read permission for top, in which case we can't

# get a list of the files the directory contains. os.path.walk

# always suppressed the exception then, rather than blow up for a

# minor reason when (say) a thousand readable directories are still

# left to visit. That logic is copied here.

try:

names = os.listdir(top)

if sortfn:

names.sort(sortfn)

else:

names.sort()

except os.error, err:

if onerror is not None:

onerror(err)

return

dirs, nondirs = [], []

for name in names:

if os.path.isdir(os.path.join(top, name)):

dirs.append(name)

else:

nondirs.append(name)

if topdown:

yield top, dirs, nondirs

for name in dirs:

path = os.path.join(top, name)

if followlinks or not os.path.islink(path):

for x in pathwalk(path, topdown, onerror, followlinks):

yield x

if not topdown:

yield top, dirs, nondirs

########################################################

# Class Properties

########################################################

# Properties let you define a class Rectangle

# and call rect.width and rect.height but have them call a function.

# Explicitly defining properties:

# https://github.com/PacktPublishing/Expert-Python-Programming_Second-Edition/blob/master/chapter3/properties_explicit.py

# Simpler syntax with decorators:

# https://github.com/PacktPublishing/Expert-Python-Programming_Second-Edition/blob/master/chapter3/properties_decorator.py

########################################################

# Useful regular expressions

########################################################

# Difference between match and search:

# match matches only from the beginning of the string,

# search will look anywhere in the string.

# Find MAC address:

match = re.search(r'([0-9A-F]{2}[:-]){5}([0-9A-F]{2})', instr, re.I)

if match: return match.group()

# Find IP address:

match = re.search(r'([0-9]{1,3}[\.]){3}([0-9]{1,3})', instr)

if match: return match.group()

########################################################

# Command-line Argument parsing

########################################################

# #python recommends click first (not installed by default),

# then argparse, over optparse.

import argparse

def parse_args():

"""Parse commandline arguments."""

parser = argparse.ArgumentParser(description="Do some stuff")

# Boolean flag

parser.add_argument('-c', "--check", dest="check", default=False,

action="store_true", help="Help string")

# int or string flag.

# Without type=, will store a string.

# For a mandatory argument, add required=True.

parser.add_argument('-b', action="store", default=2, dest="beta", type=int,

help='Beta parameter (default: 2)')

# Date

parser.add_argument('-s', "--start", dest="start_date", default=None,

help="Start date, YYYY-MM-DD, "

"default beginning of this year",

type=lambda s: datetime.datetime.strptime(s,

'%Y-%m-%d'))

# Flag that takes multiple arguments, with different names for each arg.

# Note that this is also a way around the problem of passing

# an argument that starts with a dash: argparse won't allow strings

# that start with a dash, thinking they're flags, but if they

# look like numbers with no extra characters embedded, it will

# allow them.

parser.add_argument('-a', '--area', action='store',

type=int, nargs=4,

dest='area', default=[-180, 180, -70, 74],

metavar=("west", "east", "south", "north"),

help="Area to plot")

# single positional argument

parser.add_argument('url', help='The URL to open')

parser.add_argument('urls', nargs='?', default='http://localhost/',

help="URLs to open")

# or, multiple arguments requiring at least one.

parser.add_argument('urls', nargs='+', default='http://localhost/',

help="URLs to open")

# nargs can also be an integer, but usage statements will repeat

# the argument name N times, e.g. this will say "coords coords"

# so be sure to have a good help string as well.

# If using numeric types, argparse is smart enough to allow negative vals.

parser.add_argument('coords', nargs=2, type=float,

help="longitude latitude in decimal degrees")

args = parser.parse_args(sys.argv[1:])

# Now we have args.check, args.beta, args.url or urls.

# parse_known_args() is like parse_args() except that it doesn't

# give an error if you pass extra arguments; instead, it returns

# a 2-item tuple, consisting of the arg namespace and a list of

# the remaining args:

args, rest = parser.parse_known_args(sys.argv)

# Optional argument example:

parser.add_argument('-n', "--dryrun", dest="dryrun", default=False,

action="store_true")

parser.add_argument('-s', "--sync", dest="sync", default=False,

action="store_true")

parser.add_argument("src")

parser.add_argument("dst", nargs='?')

args = parser.parse_args(sys.argv)

# For something more complicated, like different numbers of arguments

# depending on a flag, it's not clear argparse can handle that.

# See androidfiles.py for a sample workaround.

# To allow for newlines in the help strings:

parser = argparse.ArgumentParser(description="Long string\nwith newlines",

formatter_class=argparse.RawTextHelpFormatter)

# Print usage:

parser.print_help()

########################################################

# Dates and times

########################################################

# Printing formats:

>>> dt = datetime.datetime.now()

>>> dt.strftime("%Y-%m-%d %H:%M")

'2019-07-22 19:46'

>>> dt.isoformat()

'2019-07-22T19:46:20.164427'

>>> f"{dt:%Y-%m-%d %H:%M}" # Only in Python >= 3.6

'2019-07-22 19:46'

# Convert datetime to date:

now = datetime.now()

today = now.date()

##################

# Date Arithmetic

##################

# Subtracting datetimes gives a datetime.timedelta, and that's also

# a good way to add or subtract time from a datetime.

now = datetime.datetime.now()

if (now - time_end).seconds < 7200:

time_end = now - datetime.timedelta(seconds=7200)

# Setting fixed parts of datetime

dt.replace(hour=11, minute=59)

#

# Add N months to a date: same day of month but next month.

#

import datetime

from dateutil.relativedelta import relativedelta

today = datetime.date.today()

three_months_from_now = today + relativedelta(months=3)

# Note that relativedelta can also take a month= as well as a months=.

# month gives you the current dayofmonth in a specific month number;

# months gives you how many months relative to the current one.

# For differences of just days or weeks, datetime.timedelta works.

def nextmonth(d):

'''Beginning of the following month.

'''

month = d.month + 1

year = d.year

if month > 12:

month = 1

year += 1

return d.replace(day=1, month=month, year=year)

# Beginning of today:

datetime.datetime.now().replace(hour=0, minute=0,

second=0, microsecond=0)

# Earliest and latest dates:

datetime.datetime.min, datetime.datetime.max

#

# Calendar.timedelta

#

import datetime

import calendar

today = datetime.date.today()

days_this_month = calendar.monthrange(today.year, today.month)[1]

one_month_from_now = today + datetime.timedelta(days=days_this_month)

# Number of days in a month:

calendar.monthrange(year, month)[1]

# monthrange returns weekday of the first day and number of days in the month.

# Or do it using only datetime:

(datetime.datetime(year, month % 12 + 1, 1) - datetime.timedelta(days=1)).day

###############

# Date Parsing

###############

# Parse a date in RFC 2822 format.

#

datetime.datetime.strptime('2016-01-01', '%Y-%m-%d')

# Same thing with decimal seconds:

datetime.datetime.strptime('2016-01-01.234', '%Y-%m-%d.%f')

# datetime to Unix timestamp:

time.mktime(d.timetuple())

# Unix timestamp to datetime:

datetime.datetime.fromtimestamp(1553010256)

datetime.datetime.utcfromtimestamp(1553010256)

# Unfortunately there's no way, with just the Python core,

# to parse a date that might or might not have decimal seconds.

# You have to strip it off in this way, which seems horrifying

# but you'll see it recommended all over, and you'd better hope

# the decimal point is where you expect it and not some other place

# inside the string, and not something else like a comma:

timestr = '2016-01-01.234'

if '.' in timestr:

d = datetime.datetime.strptime(timestr, '%Y-%m-%d.%f')

else:

d = datetime.datetime.strptime(timestr, '%Y-%m-%d')

# email.utils.parsedate returns a tuple.

# But be warned it can only parse a full date/time, not just a date,

# even though the time part of the tuple generally isn't correct.

t = time.mktime(email.utils.parsedate("Thu, 11 Aug 2016 14:46:50 GMT")))

(y, m, d, h, m, s, weekday, yearday, isdst) = t

# the last three items of the tuple aren't very useful: typically 0, 1, -1.

# -1 means "unknown" for the dst flag.

secs_since_epoch = time.mktime(t)

t2 = time.mktime_tz(email.utils.parsedate("Thu, 11 Aug 2016 14:46:50 GMT")))

(y, m, d, h, m, s, weekday, yearday, isdst, offset_from_utc) = t2

secs_since_epoch = email.utils.mktime_tz(t2)

# Epoch to struct time:

>>> unixtime = time.time()

>>> time.gmtime(unixtime)

time.struct_time(tm_year=2021, tm_mon=6, tm_mday=8, tm_hour=1, tm_min=6, tm_sec=24, tm_wday=1, tm_yday=159, tm_isdst=0)

>>> time.localtime(unixtime)

time.struct_time(tm_year=2021, tm_mon=6, tm_mday=7, tm_hour=19, tm_min=6, tm_sec=24, tm_wday=0, tm_yday=158, tm_isdst=1)

#

# Parse a date in unknown format into a datetime.datetime object

# Unfortunately dateutil isn't part of the python core,

# it's a separate package so it adds a dependency.

# But it's more reliable than email.utils.parsedate.

#

import dateutil.parser

d = dateutil.parser.parse("2012-08-16 14:25:05.265739")

d = dateutil.parser.parse("10/31/2016 14:25")

d = dateutil.parser.parse("6/15/2016 14:25 MDT")

# There's also isodate.parse_datetime which I haven't looked into yet.

# Arrow is a Datetime replacement that offers humanize()

# to turn a date into something like "an hour ago",

# but it doesn't offer similar services for parsing.

############

# Timezones:

############

# Get the aware current local time in the local timezone:

from datetime import datetime

localnow = datetime.now().astimezone()

# dt.astimezone(tz=None) adjusts to the specified timezone,

# defaulting to the local one. tz would be a tzinfo object.

# If dt is unaware, it's presumed to be local, which is why this works.

# and then you can convert other times into that timezone:

localtz = localnow.tzinfo

localtime = othertime.astimezone(localtz)

# Note that datetime's strptime cannot parse timezone names --

# don't be misled by the documentation mentioning %Z, it lies.

# strftime can print %Z but strptime can't parse it, except UTC.

# Advice from the datetime maintainer Paul Ganssle on Talk Python to Me:

# https://talkpython.fm/episodes/show/271/unlock-the-mysteries-of-time-pythons-datetime-that-is

# https://blog.ganssle.io/

#

# recommends not using pytz (which will be dropped in 2 years).

# Instead, using the new zoneinfo coming in with python 3.9.

# (backport in pypi), or use dateutil.tz

# Don't create a datetime using tzinfo=! It will give the wrong result:

>>> dt.datetime(year=2021,month=6,day=25,hour=10,minute=0,tzinfo=pytz.timezone("America/New_York")).astimezone(dt.timezone.utc)

datetime.datetime(2021, 6, 25, 14, 56, tzinfo=datetime.timezone.utc)

# Instead, you can do one of these:

>>> dt.datetime(year=2021,month=6,day=25,hour=10,minute=0).astimezone(pytz.timezone("America/New_York")).astimezone(dt.timezone.utc)

datetime.datetime(2021, 6, 25, 16, 0, tzinfo=datetime.timezone.utc)

>>> pytz.timezone("America/New_York").localize(dt.datetime(2021,6,25,10)).astimezone(pytz.utc)

datetime.datetime(2021, 6, 25, 14, 0, tzinfo=<UTC>)

# A datetime.tzinfo object is a set of rules that include when to switch

# between DST and ST; it's not just an offset.

from dateutil import tz

MT = tz.gettz("America/Denver")

# Timezones have names, but getting them requires a date:

time_winter = datetime(2020, 2, 14, 12, tzinfo=MT)

MT.tzname(time_winter)

# -> 'MST'

time_summer = datetime(2020, 7, 14, 12, tzinfo=MT)

MT.tzname(time_summer)

# -> 'MDT'

# But see above comment about not using tzinfo= in the constructor.

# Don't use utcnow or utcfromtimestamp in modern python.

# They might even be deprecated soon. Instead:

from datetime import timezone

utcnow = datetime.now(tz=timezone.utc)

datetime.fromtimestamp(1571595618.0, tz=timezone.utc

# Take an unaware UTC datetime, like what comes from ephem.Date.datetime()

# and make it aware:

utctime = observer.date.datetime.replace(tzinfo=timezone.utc))

# Note that despite what "replace" might imply, this does not

# replace anything in the original object, merely creates a new copy.

# All pytz code should be migrated over to zoneinfo or dateutil

# and get on the PEP495 bandwagon.

# PEP 495: Local time disambiguation: https://www.python.org/dev/peps/pep-0495/